1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "ecmascript/compiler/aot_file/aot_checksum_helper.h"
19 #include "ecmascript/tests/test_helper.h"
20
21 using namespace panda::ecmascript;
22 using namespace panda::ecmascript::base;
23 namespace panda::test {
24 class AOTChecksumTest : public testing::Test {
25 public:
SetUpTestCase()26 static void SetUpTestCase()
27 {
28 GTEST_LOG_(INFO) << "SetUpTestCase";
29 }
30
TearDownTestCase()31 static void TearDownTestCase()
32 {
33 GTEST_LOG_(INFO) << "TearDownTestCase";
34 }
35
SetUp()36 void SetUp() override {}
37
TearDown()38 void TearDown() override {}
39 };
40
HWTEST_F_L0(AOTChecksumTest,ChecksumSerializeTest)41 HWTEST_F_L0(AOTChecksumTest, ChecksumSerializeTest)
42 {
43 std::unordered_map<CString, uint32_t> testMap;
44 testMap.emplace("test1.abc", 12345);
45 testMap.emplace("test2.abc", 67890);
46
47 std::vector<char> dataVector;
48 AOTChecksumHelper::SerializeChecksumMapToVector(testMap, dataVector);
49
50 ASSERT_FALSE(dataVector.empty());
51 ASSERT_EQ(dataVector.back(), '\0');
52
53 uint32_t expectedSize = AOTChecksumHelper::CalculateChecksumVectorSize(testMap);
54 ASSERT_EQ(dataVector.size(), expectedSize);
55
56 std::unordered_map<CString, uint32_t> resultMap;
57 AOTChecksumHelper::DeserializeChecksumMapFromChar(dataVector.data(), dataVector.size(), resultMap);
58
59 ASSERT_EQ(resultMap.size(), testMap.size());
60 for (const auto &pair : testMap) {
61 auto it = resultMap.find(pair.first);
62 ASSERT_TRUE(it != resultMap.end());
63 ASSERT_EQ(it->second, pair.second);
64 }
65 };
66
HWTEST_F_L0(AOTChecksumTest,EmptyMapTestTest)67 HWTEST_F_L0(AOTChecksumTest, EmptyMapTestTest)
68 {
69 std::unordered_map<CString, uint32_t> emptyMap;
70 std::vector<char> dataVector;
71 ASSERT_FALSE(AOTChecksumHelper::SerializeChecksumMapToVector(emptyMap, dataVector));
72 };
73
HWTEST_F_L0(AOTChecksumTest,MaxChecksumTest)74 HWTEST_F_L0(AOTChecksumTest, MaxChecksumTest)
75 {
76 std::unordered_map<CString, uint32_t> testMap;
77 testMap.emplace("test.abc", std::numeric_limits<uint32_t>::max());
78
79 std::vector<char> dataVector;
80 AOTChecksumHelper::SerializeChecksumMapToVector(testMap, dataVector);
81
82 ASSERT_FALSE(dataVector.empty());
83
84 std::unordered_map<CString, uint32_t> resultMap;
85 AOTChecksumHelper::DeserializeChecksumMapFromChar(dataVector.data(), dataVector.size(), resultMap);
86
87 auto it = resultMap.find("test.abc");
88 ASSERT_TRUE(it != resultMap.end());
89 ASSERT_EQ(it->second, std::numeric_limits<uint32_t>::max());
90 };
91
HWTEST_F_L0(AOTChecksumTest,MuiltiSeparator)92 HWTEST_F_L0(AOTChecksumTest, MuiltiSeparator)
93 {
94 // This case is designed to ensure that in future versions, if a filename contains colons, we should only match the
95 // first colon. If some situations that abc contains colons, for security, disable abc load an for aovid different
96 // abc checksum
97 std::unordered_map<CString, uint32_t> testMap;
98 testMap.emplace("path:to:file.abc", 12345);
99 testMap.emplace("another:path:test.abc", 67890);
100
101 std::vector<char> dataVector;
102 AOTChecksumHelper::SerializeChecksumMapToVector(testMap, dataVector);
103
104 std::unordered_map<CString, uint32_t> resultMap;
105 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar(dataVector.data(), dataVector.size(), resultMap));
106 };
107
HWTEST_F_L0(AOTChecksumTest,NullPtrProvidedTest)108 HWTEST_F_L0(AOTChecksumTest, NullPtrProvidedTest)
109 {
110 std::unordered_map<CString, uint32_t> resultMap;
111 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar(nullptr, 10, resultMap));
112 };
113
HWTEST_F_L0(AOTChecksumTest,ZeroSizeProvidedTest)114 HWTEST_F_L0(AOTChecksumTest, ZeroSizeProvidedTest)
115 {
116 std::unordered_map<CString, uint32_t> resultMap;
117 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar("test", 0, resultMap));
118 };
119
HWTEST_F_L0(AOTChecksumTest,NoSeparatorTest)120 HWTEST_F_L0(AOTChecksumTest, NoSeparatorTest)
121 {
122 std::vector<char> invalidData = {'t', 'e', 's', 't', 'g', 'o', 'o', 'd', ':', '1', '2', '3',
123 '\0', 't', 'e', 's', 't', 'b', 'a', 'd', '4', '5', '6', '\0'};
124 std::unordered_map<CString, uint32_t> resultMap;
125 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar(invalidData.data(), invalidData.size(), resultMap));
126 };
127
HWTEST_F_L0(AOTChecksumTest,NoBigEnoughBufferTest)128 HWTEST_F_L0(AOTChecksumTest, NoBigEnoughBufferTest)
129 {
130 std::unordered_map<CString, uint32_t> testMap;
131 testMap.emplace("test1.abc", 12345);
132 testMap.emplace("test2.abc", 67890);
133
134 uint32_t realSize = AOTChecksumHelper::CalculateChecksumVectorSize(testMap);
135
136 std::vector<char> smallVector(realSize - 1);
137
138 ASSERT_FALSE(AOTChecksumHelper::WriteChecksumInfoToVector(testMap, smallVector));
139 };
140
HWTEST_F_L0(AOTChecksumTest,NoFileNameTest)141 HWTEST_F_L0(AOTChecksumTest, NoFileNameTest)
142 {
143 std::vector<char> invalidData = {'t', 'e', 's', 't', 'g', 'o', 'o', 'd', ':', '1',
144 '2', '3', '\0', ':', '1', '2', '3', '4', '5', '\0'};
145
146 std::unordered_map<CString, uint32_t> resultMap;
147 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar(invalidData.data(), invalidData.size(), resultMap));
148 };
149
HWTEST_F_L0(AOTChecksumTest,NoChecksumTest)150 HWTEST_F_L0(AOTChecksumTest, NoChecksumTest)
151 {
152 std::vector<char> invalidData = {'t', 'e', 's', 't', 'g', 'o', 'o', 'd', ':',
153 '1', '2', '3', '\0', 'b', 'a', 'd', ':', '\0'};
154
155 std::unordered_map<CString, uint32_t> resultMap;
156 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar(invalidData.data(), invalidData.size(), resultMap));
157 };
158
HWTEST_F_L0(AOTChecksumTest,InvalidChecksumTest)159 HWTEST_F_L0(AOTChecksumTest, InvalidChecksumTest)
160 {
161 std::vector<char> invalidData = {'t', 'e', 's', 't', 'g', 'o', 'o', 'd', ':', '1', '2',
162 '3', '\0', 'b', 'a', 'd', ':', 'a', 'b', 'c', '\0'};
163
164 std::unordered_map<CString, uint32_t> resultMap;
165 ASSERT_FALSE(AOTChecksumHelper::DeserializeChecksumMapFromChar(invalidData.data(), invalidData.size(), resultMap));
166 };
167
HWTEST_F_L0(AOTChecksumTest,NotFullFillChecksumVecTest)168 HWTEST_F_L0(AOTChecksumTest, NotFullFillChecksumVecTest)
169 {
170 std::unordered_map<CString, uint32_t> testMap;
171 testMap.emplace("test1.abc", 12345);
172 testMap.emplace("test2.abc", 67890);
173
174 uint32_t correctSize = AOTChecksumHelper::CalculateChecksumVectorSize(testMap);
175 std::vector<char> tooLargeVector(correctSize + 10);
176
177 ASSERT_FALSE(AOTChecksumHelper::WriteChecksumInfoToVector(testMap, tooLargeVector));
178 };
179
180 } // namespace panda::test
181