1 /*
2 * Copyright (c) 2023 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 "ecmascript/ecma_string-inl.h"
17 #include "ecmascript/object_factory.h"
18 #include "ecmascript/tests/ecma_test_common.h"
19
20 using namespace panda::ecmascript;
21
22 namespace panda::test {
23 class ConstantStringTest : public BaseTestWithScope<false> {
24 };
25
26 /*
27 * @tc.name: CreateConstantString
28 * @tc.desc: Check whether the EcmaString created through calling CreateConstantString function is within expectations.
29 * @tc.type: FUNC
30 * @tc.require:
31 */
HWTEST_F_L0(ConstantStringTest,CreateEmptyString)32 HWTEST_F_L0(ConstantStringTest, CreateEmptyString)
33 {
34 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateConstantString(instance, nullptr,
35 0U, true));
36 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrEmpty).IsConstantString());
37 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).GetLength(), 0U);
38 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrEmpty).IsUtf8());
39 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrEmpty).IsUtf16());
40 }
41
42 /*
43 * @tc.name: CreateConstantString
44 * @tc.desc: Check whether the EcmaString created through calling CreateConstantString function is within expectations.
45 * @tc.type: FUNC
46 * @tc.require:
47 */
HWTEST_F_L0(ConstantStringTest,CreateConstantString)48 HWTEST_F_L0(ConstantStringTest, CreateConstantString)
49 {
50 uint8_t arrayU8[] = {"xyz123!@#"};
51 size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
52 JSHandle<EcmaString> handleEcmaStrU8(thread,
53 EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
54 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
55 EXPECT_EQ(arrayU8[i], EcmaStringAccessor(handleEcmaStrU8).Get(i));
56 }
57 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetLength(), lengthEcmaStrU8);
58 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU8).IsUtf8());
59 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU8).IsUtf16());
60 }
61
62 /*
63 * @tc.name: ObjectSize
64 * @tc.desc: Check whether the value returned through calling ObjectSize function is within expectations.
65 * @tc.type: FUNC
66 * @tc.require:
67 */
HWTEST_F_L0(ConstantStringTest,ObjectSize)68 HWTEST_F_L0(ConstantStringTest, ObjectSize)
69 {
70 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateConstantString(instance, nullptr,
71 0U, true));
72 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).ObjectSize(), ConstantString::SIZE);
73
74 uint8_t arrayU8[] = {"abcde"};
75 size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
76 JSHandle<EcmaString> handleEcmaStrU8(thread,
77 EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
78 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).ObjectSize(), ConstantString::SIZE);
79 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetLength(), lengthEcmaStrU8);
80 }
81
82 /*
83 * @tc.name: Compare_001
84 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by
85 * CreateFromUtf8() is within expectations.
86 * @tc.type: FUNC
87 * @tc.require:
88 */
HWTEST_F_L0(ConstantStringTest,Compare_001)89 HWTEST_F_L0(ConstantStringTest, Compare_001)
90 {
91 // Compare(). Between EcmaStrings made by CreateConstantString().
92 uint8_t arrayU8No1[3] = {1, 23};
93 uint8_t arrayU8No2[4] = {1, 23, 49};
94 uint8_t arrayU8No3[6] = {1, 23, 45, 97, 127};
95 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
96 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
97 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
98 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
99 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
100 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
101 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
102 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
103 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
104 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU8No2), -1);
105 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No1), 1);
106 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No3), 49 - 45);
107 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No3, handleEcmaStrU8No2), 45 - 49);
108 }
109
110 /*
111 * @tc.name: Compare_005
112 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by
113 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
114 * @tc.type: FUNC
115 * @tc.require:
116 */
HWTEST_F_L0(ConstantStringTest,Compare_005)117 HWTEST_F_L0(ConstantStringTest, Compare_005)
118 {
119 // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false).
120 uint8_t arrayU8No1[3] = {1, 23};
121 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
122 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
123 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
124
125 uint8_t arrayU8No2[4] = {1, 23, 49};
126 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
127 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
128 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
129
130 uint16_t arrayU16NotCompNo1[] = {1, 23};
131 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
132 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
133 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
134
135 uint16_t arrayU16NotCompNo2[] = {1, 23, 49};
136 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
137 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
138 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, true));
139
140 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127};
141 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
142 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
143 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
144
145 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo1), 0);
146 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU8No1), 0);
147 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo2), -1);
148 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU8No1), 1);
149 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU16NotCompNo3), 49 - 456);
150 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU8No2), 456 - 49);
151 }
152
153 /*
154 * @tc.name: Concat_001
155 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
156 * CreateConstantString() and EcmaString made by CreateConstantString() is within expectations.
157 * @tc.type: FUNC
158 * @tc.require:
159 */
HWTEST_F_L0(ConstantStringTest,Concat_001)160 HWTEST_F_L0(ConstantStringTest, Concat_001)
161 {
162 // Concat(). EcmaString made by CreateConstantString() and EcmaString made by CreateConstantString().
163 uint8_t arrayFrontU8[] = {"abcdef"};
164 uint8_t arrayBackU8[] = {"ABCDEF"};
165 uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1;
166 uint32_t lengthEcmaStrBackU8 = sizeof(arrayBackU8) - 1;
167 JSHandle<EcmaString> handleEcmaStrFrontU8(thread,
168 EcmaStringAccessor::CreateConstantString(instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true));
169 JSHandle<EcmaString> handleEcmaStrBackU8(thread,
170 EcmaStringAccessor::CreateConstantString(instance, &arrayBackU8[0], lengthEcmaStrBackU8, true));
171 JSHandle<EcmaString> handleEcmaStrConcatU8(thread,
172 EcmaStringAccessor::Concat(instance, handleEcmaStrFrontU8, handleEcmaStrBackU8));
173 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrConcatU8).IsUtf8());
174 for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) {
175 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).Get(i), arrayFrontU8[i]);
176 }
177 for (uint32_t i = 0; i < lengthEcmaStrBackU8; i++) {
178 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).Get(i + lengthEcmaStrFrontU8), arrayBackU8[i]);
179 }
180 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).GetLength(), lengthEcmaStrFrontU8 + lengthEcmaStrBackU8);
181 }
182
183 /*
184 * @tc.name: Concat_003
185 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
186 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
187 * @tc.type: FUNC
188 * @tc.require:
189 */
HWTEST_F_L0(ConstantStringTest,Concat_003)190 HWTEST_F_L0(ConstantStringTest, Concat_003)
191 {
192 // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false).
193 uint8_t arrayFrontU8[] = {"abcdef"};
194 uint16_t arrayBackU16NotComp[] = {88, 768, 1, 270, 345, 333};
195 uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1;
196 uint32_t lengthEcmaStrBackU16NotComp = sizeof(arrayBackU16NotComp) / sizeof(arrayBackU16NotComp[0]);
197 JSHandle<EcmaString> handleEcmaStrFrontU8(thread,
198 EcmaStringAccessor::CreateConstantString(instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true));
199 JSHandle<EcmaString> handleEcmaStrBackU16NotComp(thread,
200 EcmaStringAccessor::CreateFromUtf16(instance, &arrayBackU16NotComp[0], lengthEcmaStrBackU16NotComp, false));
201 JSHandle<EcmaString> handleEcmaStrConcatU8U16NotComp(thread,
202 EcmaStringAccessor::Concat(instance, handleEcmaStrFrontU8, handleEcmaStrBackU16NotComp));
203 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).IsUtf16());
204 for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) {
205 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).Get(i), arrayFrontU8[i]);
206 }
207 for (uint32_t i = 0; i < lengthEcmaStrBackU16NotComp; i++) {
208 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).Get(i + lengthEcmaStrFrontU8),
209 arrayBackU16NotComp[i]);
210 }
211 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).GetLength(),
212 lengthEcmaStrFrontU8 + lengthEcmaStrBackU16NotComp);
213 }
214
215 /*
216 * @tc.name: FastSubString_001
217 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by
218 * CreateConstantString() is within expectations.
219 * @tc.type: FUNC
220 * @tc.require:
221 */
HWTEST_F_L0(ConstantStringTest,FastSubString_001)222 HWTEST_F_L0(ConstantStringTest, FastSubString_001)
223 {
224 // FastSubString(). From EcmaString made by CreateConstantString().
225 std::vector<uint8_t> arrayU8{3, 7, 19, 54, 99};
226 auto func = std::bind(EcmaStringAccessor::CreateConstantString, std::placeholders::_1, std::placeholders::_2,
227 std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, 0);
228 EcmaTestCommon::FastSubStringCommonCase(thread, instance, arrayU8, func);
229 }
230
231 /*
232 * @tc.name: GetUtf8Length
233 * @tc.desc: Check whether the value returned through calling GetUtf8Length function is within expectations.
234 * @tc.type: FUNC
235 * @tc.require:
236 */
HWTEST_F_L0(ConstantStringTest,GetUtf8Length)237 HWTEST_F_L0(ConstantStringTest, GetUtf8Length)
238 {
239 uint8_t arrayU8[6] = {3, 7, 19, 54, 99};
240 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
241 JSHandle<EcmaString> handleEcmaStrU8(thread,
242 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
243 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetUtf8Length(), lengthEcmaStrU8 + 1);
244 }
245
246 /*
247 * @tc.name: GetDataUtf8
248 * @tc.desc: Check whether the pointer returned through calling GetDataUtf8 function is within expectations.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
HWTEST_F_L0(ConstantStringTest,GetDataUtf8)252 HWTEST_F_L0(ConstantStringTest, GetDataUtf8)
253 {
254 // From EcmaString made by CreateFromUtf8().
255 uint8_t arrayU8[] = {"abcde"};
256 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
257 JSHandle<EcmaString> handleEcmaStrU8(thread,
258 EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
259 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
260 EXPECT_EQ(*(EcmaStringAccessor(handleEcmaStrU8).GetDataUtf8() + i), arrayU8[i]);
261 }
262 }
263
264 /*
265 * @tc.name: IndexOf_001
266 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateConstantString() calling
267 * IndexOf function with a target EcmaString made by CreateConstantString() is within expectations.
268 * @tc.type: FUNC
269 * @tc.require:
270 */
HWTEST_F_L0(ConstantStringTest,IndexOf_001)271 HWTEST_F_L0(ConstantStringTest, IndexOf_001)
272 {
273 // IndexOf(). Find EcmaString made by CreateConstantString() From EcmaString made by CreateConstantString().
274 uint8_t arrayU8From[7] = {23, 25, 1, 3, 39, 80};
275 uint8_t arrayU8Target[4] = {1, 3, 39};
276 uint32_t lengthEcmaStrU8From = sizeof(arrayU8From) - 1;
277 uint32_t lengthEcmaStrU8Target = sizeof(arrayU8Target) - 1;
278 JSHandle<EcmaString> handleEcmaStr(thread,
279 EcmaStringAccessor::CreateConstantString(instance, &arrayU8From[0], lengthEcmaStrU8From, true));
280 JSHandle<EcmaString> handleEcmaStr1(thread,
281 EcmaStringAccessor::CreateConstantString(instance, &arrayU8Target[0], lengthEcmaStrU8Target, true));
282 int32_t posStart = 0;
283 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
284 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), -1);
285 posStart = -1;
286 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
287 posStart = 1;
288 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
289 posStart = 2;
290 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
291 posStart = 3;
292 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), -1);
293 }
294
295 /*
296 * @tc.name: IndexOf_004
297 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateConstantString() calling
298 * IndexOf function with a target EcmaString made by CreateFromUtf16() is within expectations.
299 * @tc.type: FUNC
300 * @tc.require:
301 */
HWTEST_F_L0(ConstantStringTest,IndexOf_004)302 HWTEST_F_L0(ConstantStringTest, IndexOf_004)
303 {
304 // IndexOf(). Find EcmaString made by CreateFromUtf16() From EcmaString made by CreateConstantString().
305 std::vector<uint16_t> ecmaStrU16NotCompTarget = {3, 39, 80};
306 std::vector<uint8_t> arrayU8From{23, 25, 1, 3, 39, 80};
307 auto func = std::bind(EcmaStringAccessor::CreateConstantString, std::placeholders::_1, std::placeholders::_2,
308 std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, 0);
309 EcmaTestCommon::IndexOfCommonCase(thread, instance, ecmaStrU16NotCompTarget, arrayU8From, func);
310 }
311
312 /*
313 * @tc.name: StringsAreEqual_001
314 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by
315 * CreateConstantString() is within expectations.
316 * @tc.type: FUNC
317 * @tc.require:
318 */
HWTEST_F_L0(ConstantStringTest,StringsAreEqual_001)319 HWTEST_F_L0(ConstantStringTest, StringsAreEqual_001)
320 {
321 // StringsAreEqual().
322 uint8_t arrayU8No1[4] = {45, 92, 78};
323 uint8_t arrayU8No2[4] = {45, 92, 78};
324 uint8_t arrayU8No3[5] = {45, 92, 78, 1};
325 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
326 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
327 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
328 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
329 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
330 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
331 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
332 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
333 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
334 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU8No2));
335 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU8No3));
336 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No3, *handleEcmaStrU8No1));
337 }
338
339 /*
340 * @tc.name: StringsAreEqual_002
341 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by
342 * CreateConstantString() and a EcmaString made by CreateFromUtf16(, , , true) is within expectations.
343 * @tc.type: FUNC
344 * @tc.require:
345 */
HWTEST_F_L0(ConstantStringTest,StringsAreEqual_002)346 HWTEST_F_L0(ConstantStringTest, StringsAreEqual_002)
347 {
348 // StringsAreEqual().
349 uint8_t arrayU8No1[4] = {45, 92, 78};
350 uint16_t arrayU16CompNo2[] = {45, 92, 78};
351 uint16_t arrayU16CompNo3[] = {45, 92, 78, 1};
352 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
353 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
354 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
355 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
356 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
357 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
358 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
359 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
360 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
361 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16CompNo2));
362 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16CompNo3));
363 }
364
365 /*
366 * @tc.name: StringsAreEqualUtf8_001
367 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made by
368 * CreateConstantString() and an Array(uint8_t) is within expectations.
369 * @tc.type: FUNC
370 * @tc.require:
371 */
HWTEST_F_L0(ConstantStringTest,StringsAreEqualUtf8_001)372 HWTEST_F_L0(ConstantStringTest, StringsAreEqualUtf8_001)
373 {
374 // StringIsEqualUint8Data(). EcmaString made by CreateConstantString(), Array:U8.
375 uint8_t arrayU8No1[4] = {45, 92, 78};
376 uint8_t arrayU8No2[5] = {45, 92, 78, 24};
377 uint8_t arrayU8No3[3] = {45, 92};
378 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
379 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
380 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
381 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
382 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
383 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
384 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
385 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
386 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
387 EXPECT_TRUE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No1, &arrayU8No1[0], lengthEcmaStrU8No1,
388 true));
389 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No1, &arrayU8No1[0], lengthEcmaStrU8No1,
390 false));
391 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No2, &arrayU8No1[0], lengthEcmaStrU8No1,
392 true));
393 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No3, &arrayU8No1[0], lengthEcmaStrU8No1,
394 true));
395 }
396
397 /*
398 * @tc.name: StringsAreEqualUtf16_001
399 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made by
400 * CreateConstantString() and an Array(uint16_t) is within expectations.
401 * @tc.type: FUNC
402 * @tc.require:
403 */
HWTEST_F_L0(ConstantStringTest,StringsAreEqualUtf16_001)404 HWTEST_F_L0(ConstantStringTest, StringsAreEqualUtf16_001)
405 {
406 // StringsAreEqualUtf16(). EcmaString made by CreateConstantString, Array:U16(1-127).
407 uint8_t arrayU8No3[3] = {45, 92};
408 uint8_t arrayU8No1[4] = {45, 92, 78};
409 uint8_t arrayU8No2[5] = {45, 92, 78, 24};
410 uint16_t arrayU16NotCompNo1[] = {45, 92, 78};
411 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
412 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
413 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
414 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
415 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
416 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
417 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
418 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
419 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
420 EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
421 EXPECT_TRUE(
422 EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU8No1,
423 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
424 EXPECT_FALSE(
425 EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU8No2,
426 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
427 EXPECT_FALSE(
428 EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU8No3,
429 &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
430 }
431
432 /*
433 * @tc.name: GetHashcode_001
434 * @tc.desc: Check whether the value returned through an EcmaString made by CreateConstantString() calling
435 * GetHashcode function is within expectations.
436 * @tc.type: FUNC
437 * @tc.require:
438 */
HWTEST_F_L0(ConstantStringTest,GetHashcode_001)439 HWTEST_F_L0(ConstantStringTest, GetHashcode_001)
440 {
441 // GetHashcode(). EcmaString made by CreateConstantString().
442 uint8_t arrayU8[] = {"abc"};
443 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
444 JSHandle<EcmaString> handleEcmaStrU8(thread,
445 EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
446 uint32_t hashExpect = 0;
447 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
448 hashExpect = hashExpect * 31 + arrayU8[i];
449 }
450 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetHashcode(), hashExpect);
451 }
452
453 /*
454 * @tc.name: SetIsInternString
455 * @tc.desc: Call SetIsInternString function, check whether the bool returned through calling IsInternString function
456 * is within expectations.
457 * @tc.type: FUNC
458 * @tc.require:
459 */
HWTEST_F_L0(ConstantStringTest,SetIsInternString)460 HWTEST_F_L0(ConstantStringTest, SetIsInternString)
461 {
462 uint8_t arrayU8[] = {"abc"};
463 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
464 JSHandle<EcmaString> handleEcmaStrU8(thread,
465 EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
466 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU8).IsInternString());
467 EcmaStringAccessor(handleEcmaStrU8).SetInternString();
468 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU8).IsInternString());
469 }
470
471 /*
472 * @tc.name: EqualToSplicedString
473 * @tc.desc: Tests whether the source string is equal to the concatenated string.
474 * is within expectations.
475 * @tc.type: FUNC
476 * @tc.require:
477 */
HWTEST_F_L0(ConstantStringTest,EqualToSplicedString)478 HWTEST_F_L0(ConstantStringTest, EqualToSplicedString)
479 {
480 uint8_t arrayU8[] = {"Startnow"};
481 uint32_t srcLengthEcmaStrU8 = sizeof(arrayU8) - 1;
482 JSHandle<EcmaString> sourceString(thread,
483 EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], srcLengthEcmaStrU8, true));
484 uint8_t firstArrayU8[] = {"Start"};
485 uint32_t firstLengthEcmaStrU8 = sizeof(firstArrayU8) - 1;
486 JSHandle<EcmaString> firstString(thread,
487 EcmaStringAccessor::CreateConstantString(instance, &firstArrayU8[0], firstLengthEcmaStrU8, true));
488 uint8_t secondArrayU8[] = {"now"};
489 uint32_t secondLengthEcmaStrU8 = sizeof(secondArrayU8) - 1;
490 JSHandle<EcmaString> secondString(thread,
491 EcmaStringAccessor::CreateConstantString(instance, &secondArrayU8[0], secondLengthEcmaStrU8, true));
492
493 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf8());
494 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
495 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf8());
496 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
497 EXPECT_TRUE(result);
498 }
499
500 /*
501 * @tc.name: TryToLower
502 * @tc.desc: Check whether the EcmaString created through calling TryToLower function is within expectations.
503 * is within expectations.
504 * @tc.type: FUNC
505 * @tc.require:
506 */
HWTEST_F_L0(ConstantStringTest,ConvertUtf8ToLowerOrUpper)507 HWTEST_F_L0(ConstantStringTest, ConvertUtf8ToLowerOrUpper)
508 {
509 uint8_t lowerU8[] = {"aaabbbcccddd"};
510 uint32_t lowerLength = sizeof(lowerU8) - 1;
511 JSHandle<EcmaString> lowerStr(thread,
512 EcmaStringAccessor::CreateConstantString(instance, &lowerU8[0], lowerLength, true));
513 uint8_t upperU8[] = {"AAABBBCCCDDD"};
514 uint32_t upperLength = sizeof(upperU8) - 1;
515 JSHandle<EcmaString> upperStr(thread,
516 EcmaStringAccessor::CreateConstantString(instance, &upperU8[0], upperLength, true));
517
518 uint8_t testStr1U8[] = {"aaaBBBcccDDD"};
519 uint32_t testLength1 = sizeof(testStr1U8) - 1;
520 JSHandle<EcmaString> testStr1(thread,
521 EcmaStringAccessor::CreateConstantString(instance, &testStr1U8[0], testLength1, true));
522
523 uint8_t testStr2U8[] = {"AAAbbbcccDDD"};
524 uint32_t testLength2 = sizeof(testStr2U8) - 1;
525 JSHandle<EcmaString> testStr2(thread,
526 EcmaStringAccessor::CreateConstantString(instance, &testStr2U8[0], testLength2, true));
527 std::vector<JSHandle<EcmaString>> caseStrings{upperStr, testStr1, testStr2};
528 EcmaTestCommon::TryLowerCommonCase(thread, instance, lowerStr, caseStrings);
529 }
530 } // namespace panda::test