1 /*
2 * Copyright (c) 2022 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 LineEcmaStringTest : public BaseTestWithScope<false> {
24 };
25
26 /*
27 * @tc.name: ComputeSizeUtf8
28 * @tc.desc: Check whether the value returned through calling ComputeSizeUtf8 function is within expectations.
29 * @tc.type: FUNC
30 * @tc.require:
31 */
HWTEST_F_L0(LineEcmaStringTest,ComputeSizeUtf8)32 HWTEST_F_L0(LineEcmaStringTest, ComputeSizeUtf8)
33 {
34 uint32_t scale = 3333;
35 for (uint32_t i = EcmaString::MAX_STRING_LENGTH - 1; i > scale; i = i - scale) {
36 uint32_t length = i;
37 EXPECT_EQ(LineEcmaString::ComputeSizeUtf8(length), length + LineEcmaString::SIZE);
38 }
39 }
40
41 /*
42 * @tc.name: ComputeSizeUtf16
43 * @tc.desc: Check whether the value returned through calling ComputeSizeUtf16 function is within expectations.
44 * @tc.type: FUNC
45 * @tc.require:
46 */
HWTEST_F_L0(LineEcmaStringTest,ComputeSizeUtf16)47 HWTEST_F_L0(LineEcmaStringTest, ComputeSizeUtf16)
48 {
49 uint32_t scale = 3333;
50 for (uint32_t i = EcmaString::MAX_STRING_LENGTH - 1; i > scale; i = i - scale) {
51 uint32_t length = i;
52 EXPECT_EQ(LineEcmaString::ComputeSizeUtf16(length), 2 * length + LineEcmaString::SIZE);
53 }
54 }
55
56 class EcmaStringAccessorTest : public BaseTestWithScope<false> {
57 };
58
59 /*
60 * @tc.name: CreateLineString
61 * @tc.desc: Check whether the EcmaString created through calling CreateLineString function is within expectations.
62 * @tc.type: FUNC
63 * @tc.require:
64 */
HWTEST_F_L0(EcmaStringAccessorTest,CreateLineString)65 HWTEST_F_L0(EcmaStringAccessorTest, CreateLineString)
66 {
67 // CreateLineString( , true, ).
68 size_t sizeAllocComp = 5;
69 JSHandle<EcmaString> handleEcmaStrAllocComp(thread,
70 EcmaStringAccessor::CreateLineString(instance, sizeAllocComp, true));
71 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocComp).GetLength(), sizeAllocComp);
72 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrAllocComp).IsUtf8());
73 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrAllocComp).IsUtf16());
74
75 // CreateLineString( , false, ).
76 size_t sizeAllocNotComp = 5;
77 JSHandle<EcmaString> handleEcmaStrAllocNotComp(thread,
78 EcmaStringAccessor::CreateLineString(instance, sizeAllocNotComp, false));
79 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocNotComp).GetLength(), sizeAllocNotComp);
80 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrAllocNotComp).IsUtf8());
81 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrAllocNotComp).IsUtf16());
82 }
83
84 /*
85 * @tc.name: CreateEmptyString
86 * @tc.desc: Check whether the EcmaString created through calling CreateEmptyString function is within expectations.
87 * @tc.type: FUNC
88 * @tc.require:
89 */
HWTEST_F_L0(EcmaStringAccessorTest,CreateEmptyString)90 HWTEST_F_L0(EcmaStringAccessorTest, CreateEmptyString)
91 {
92 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateEmptyString(instance));
93 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).GetLength(), 0U);
94 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrEmpty).IsUtf8());
95 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrEmpty).IsUtf16());
96 }
97
98 /*
99 * @tc.name: CreateFromUtf8
100 * @tc.desc: Check whether the EcmaString created through calling CreateFromUtf8 function is within expectations.
101 * @tc.type: FUNC
102 * @tc.require:
103 */
HWTEST_F_L0(EcmaStringAccessorTest,CreateFromUtf8)104 HWTEST_F_L0(EcmaStringAccessorTest, CreateFromUtf8)
105 {
106 uint8_t arrayU8[] = {"xyz123!@#"};
107 size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
108 JSHandle<EcmaString> handleEcmaStrU8(thread,
109 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
110 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
111 EXPECT_EQ(arrayU8[i], EcmaStringAccessor(handleEcmaStrU8).Get(i));
112 }
113 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetLength(), lengthEcmaStrU8);
114 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU8).IsUtf8());
115 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU8).IsUtf16());
116 }
117
118 /*
119 * @tc.name: CreateFromUtf16
120 * @tc.desc: Check whether the EcmaString created through calling CreateFromUtf16 function is within expectations.
121 * @tc.type: FUNC
122 * @tc.require:
123 */
HWTEST_F_L0(EcmaStringAccessorTest,CreateFromUtf16)124 HWTEST_F_L0(EcmaStringAccessorTest, CreateFromUtf16)
125 {
126 // CreateFromUtf16( , , , true).
127 uint16_t arrayU16Comp[] = {1, 23, 45, 67, 127};
128 size_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
129 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
130 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
131 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16Comp).GetLength(), lengthEcmaStrU16Comp);
132 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU16Comp).IsUtf8());
133 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU16Comp).IsUtf16());
134
135 // CreateFromUtf16( , , , false).
136 uint16_t arrayU16NotComp[] = {127, 33, 128, 12, 256, 11100, 65535};
137 size_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
138 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
139 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, false));
140 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16NotComp).GetLength(), lengthEcmaStrU16NotComp);
141 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU16NotComp).IsUtf8());
142 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU16NotComp).IsUtf16());
143 }
144
145 /*
146 * @tc.name: Concat_001
147 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
148 * CreateFromUtf8() and EcmaString made by CreateFromUtf8() is within expectations.
149 * @tc.type: FUNC
150 * @tc.require:
151 */
HWTEST_F_L0(EcmaStringAccessorTest,Concat_001)152 HWTEST_F_L0(EcmaStringAccessorTest, Concat_001)
153 {
154 // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf8().
155 uint8_t arrayFrontU8[] = {"abcdef"};
156 uint8_t arrayBackU8[] = {"ABCDEF"};
157 uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1;
158 uint32_t lengthEcmaStrBackU8 = sizeof(arrayBackU8) - 1;
159 JSHandle<EcmaString> handleEcmaStrFrontU8(thread,
160 EcmaStringAccessor::CreateFromUtf8(instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true));
161 JSHandle<EcmaString> handleEcmaStrBackU8(thread,
162 EcmaStringAccessor::CreateFromUtf8(instance, &arrayBackU8[0], lengthEcmaStrBackU8, true));
163 JSHandle<EcmaString> handleEcmaStrConcatU8(thread,
164 EcmaStringAccessor::Concat(instance, handleEcmaStrFrontU8, handleEcmaStrBackU8));
165 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrConcatU8).IsUtf8());
166 for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) {
167 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).Get(i), arrayFrontU8[i]);
168 }
169 for (uint32_t i = 0; i < lengthEcmaStrBackU8; i++) {
170 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).Get(i + lengthEcmaStrFrontU8), arrayBackU8[i]);
171 }
172 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).GetLength(), lengthEcmaStrFrontU8 + lengthEcmaStrBackU8);
173 }
174
175 /*
176 * @tc.name: Concat_002
177 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
178 * CreateFromUtf16( , , , false) and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
179 * @tc.type: FUNC
180 * @tc.require:
181 */
HWTEST_F_L0(EcmaStringAccessorTest,Concat_002)182 HWTEST_F_L0(EcmaStringAccessorTest, Concat_002)
183 {
184 // Concat(). EcmaString made by CreateFromUtf16( , , , false) and EcmaString made by CreateFromUtf16( , , , false).
185 uint16_t arrayFrontU16NotComp[] = {128, 129, 256, 11100, 65535, 100};
186 uint16_t arrayBackU16NotComp[] = {88, 768, 1, 270, 345, 333};
187 uint32_t lengthEcmaStrFrontU16NotComp = sizeof(arrayFrontU16NotComp) / sizeof(arrayFrontU16NotComp[0]);
188 uint32_t lengthEcmaStrBackU16NotComp = sizeof(arrayBackU16NotComp) / sizeof(arrayBackU16NotComp[0]);
189 JSHandle<EcmaString> handleEcmaStrFrontU16NotComp(thread,
190 EcmaStringAccessor::CreateFromUtf16(instance, &arrayFrontU16NotComp[0], lengthEcmaStrFrontU16NotComp, false));
191 JSHandle<EcmaString> handleEcmaStrBackU16NotComp(thread,
192 EcmaStringAccessor::CreateFromUtf16(instance, &arrayBackU16NotComp[0], lengthEcmaStrBackU16NotComp, false));
193 JSHandle<EcmaString> handleEcmaStrConcatU16NotComp(thread,
194 EcmaStringAccessor::Concat(instance, handleEcmaStrFrontU16NotComp, handleEcmaStrBackU16NotComp));
195 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrConcatU16NotComp).IsUtf16());
196 for (uint32_t i = 0; i < lengthEcmaStrFrontU16NotComp; i++) {
197 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU16NotComp).Get(i), arrayFrontU16NotComp[i]);
198 }
199 for (uint32_t i = 0; i < lengthEcmaStrBackU16NotComp; i++) {
200 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU16NotComp).Get(i + lengthEcmaStrFrontU16NotComp),
201 arrayBackU16NotComp[i]);
202 }
203 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU16NotComp).GetLength(),
204 lengthEcmaStrFrontU16NotComp + lengthEcmaStrBackU16NotComp);
205 }
206
207 /*
208 * @tc.name: Concat_003
209 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
210 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
211 * @tc.type: FUNC
212 * @tc.require:
213 */
HWTEST_F_L0(EcmaStringAccessorTest,Concat_003)214 HWTEST_F_L0(EcmaStringAccessorTest, Concat_003)
215 {
216 // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false).
217 EcmaTestCommon::ConcatCommonCase2(thread, instance, true);
218 }
219
220 /*
221 * @tc.name: FastSubString_001
222 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by
223 * CreateFromUtf8() is within expectations.
224 * @tc.type: FUNC
225 * @tc.require:
226 */
HWTEST_F_L0(EcmaStringAccessorTest,FastSubString_001)227 HWTEST_F_L0(EcmaStringAccessorTest, FastSubString_001)
228 {
229 // FastSubString(). From EcmaString made by CreateFromUtf8().
230 std::vector<uint8_t> arrayU8{3, 7, 19, 54, 99};
231 auto func = std::bind(EcmaStringAccessor::CreateFromUtf8, std::placeholders::_1, std::placeholders::_2,
232 std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, false, 0);
233 EcmaTestCommon::FastSubStringCommonCase(thread, instance, arrayU8, func);
234 }
235
236 /*
237 * @tc.name: FastSubString_002
238 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by
239 * CreateFromUtf16( , , , true) is within expectations.
240 * @tc.type: FUNC
241 * @tc.require:
242 */
HWTEST_F_L0(EcmaStringAccessorTest,FastSubString_002)243 HWTEST_F_L0(EcmaStringAccessorTest, FastSubString_002)
244 {
245 // FastSubString(). From EcmaString made by CreateFromUtf16( , , , true).
246 uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127};
247 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
248 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
249 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
250 uint32_t indexStartSubU16Comp = 0;
251 uint32_t lengthSubU16Comp = 2;
252 JSHandle<EcmaString> handleEcmaStrSubU16Comp(thread,
253 EcmaStringAccessor::FastSubString(instance, handleEcmaStrU16Comp, indexStartSubU16Comp, lengthSubU16Comp));
254 for (uint32_t i = 0; i < lengthSubU16Comp; i++) {
255 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrSubU16Comp).Get(i),
256 EcmaStringAccessor(handleEcmaStrU16Comp).Get(i + indexStartSubU16Comp));
257 }
258 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrSubU16Comp).GetLength(), lengthSubU16Comp);
259 }
260
261 /*
262 * @tc.name: FastSubString_003
263 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by
264 * CreateFromUtf16( , , , false) is within expectations.
265 * @tc.type: FUNC
266 * @tc.require:
267 */
HWTEST_F_L0(EcmaStringAccessorTest,FastSubString_003)268 HWTEST_F_L0(EcmaStringAccessorTest, FastSubString_003)
269 {
270 // FastSubString(). From EcmaString made by CreateFromUtf16( , , , false).
271 uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535};
272 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
273 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
274 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, false));
275 uint32_t indexStartSubU16NotComp = 0;
276 uint32_t lengthSubU16NotComp = 2;
277 JSHandle<EcmaString> handleEcmaStrSubU16NotComp(thread, EcmaStringAccessor::FastSubString(
278 instance, handleEcmaStrU16NotComp, indexStartSubU16NotComp, lengthSubU16NotComp));
279 for (uint32_t i = 0; i < lengthSubU16NotComp; i++) {
280 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrSubU16NotComp).Get(i),
281 EcmaStringAccessor(handleEcmaStrU16NotComp).Get(i + indexStartSubU16NotComp));
282 }
283 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrSubU16NotComp).GetLength(), lengthSubU16NotComp);
284 }
285
286 /*
287 * @tc.name: FastSubString_004
288 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString
289 * @tc.type: FUNC
290 * @tc.require:
291 */
HWTEST_F_L0(EcmaStringAccessorTest,FastSubString_004)292 HWTEST_F_L0(EcmaStringAccessorTest, FastSubString_004)
293 {
294 ObjectFactory* factory = instance->GetFactory();
295 {
296 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("整数integer");
297 JSHandle<EcmaString> tmpString = factory->NewFromASCII("integer");
298 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
299 EcmaString *res = EcmaStringAccessor::FastSubString(instance, sourceString, 2, 7);
300 EXPECT_TRUE(EcmaStringAccessor(res).IsUtf8());
301 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(res, *tmpString));
302 }
303 {
304 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("整数integer");
305 JSHandle<EcmaString> tmpString = factory->NewFromUtf8("整数");
306 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
307 EcmaString *res = EcmaStringAccessor::FastSubString(instance, sourceString, 0, 2);
308 EXPECT_TRUE(EcmaStringAccessor(res).IsUtf16());
309 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(res, *tmpString));
310 }
311 {
312 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("整数integer");
313 JSHandle<EcmaString> tmpString = factory->NewFromUtf8("数intege");
314 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
315 EcmaString *res = EcmaStringAccessor::FastSubString(instance, sourceString, 1, 7);
316 EXPECT_TRUE(EcmaStringAccessor(res).IsUtf16());
317 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(res, *tmpString));
318 }
319 {
320 JSHandle<EcmaString> sourceString = factory->NewFromASCII("integer123");
321 JSHandle<EcmaString> tmpString = factory->NewFromASCII("integer");
322 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf8());
323 EcmaString *res = EcmaStringAccessor::FastSubString(instance, sourceString, 0, 7);
324 EXPECT_TRUE(EcmaStringAccessor(res).IsUtf8());
325 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(res, *tmpString));
326 }
327 }
328
329 /*
330 * @tc.name: GetUtf8Length
331 * @tc.desc: Check whether the value returned through calling GetUtf8Length function is within expectations.
332 * @tc.type: FUNC
333 * @tc.require:
334 */
HWTEST_F_L0(EcmaStringAccessorTest,GetUtf8Length)335 HWTEST_F_L0(EcmaStringAccessorTest, GetUtf8Length)
336 {
337 uint8_t arrayU8[6] = {3, 7, 19, 54, 99};
338 uint16_t arrayU16Comp[] = {1, 12, 34, 56, 127};
339 uint16_t arrayU16NotComp[] = {19, 54, 256, 11100, 65535};
340 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
341 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
342 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
343 JSHandle<EcmaString> handleEcmaStrU8(thread,
344 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
345 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
346 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
347 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
348 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, false));
349 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetUtf8Length(), lengthEcmaStrU8 + 1);
350 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16Comp).GetUtf8Length(), lengthEcmaStrU16Comp + 1);
351 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16NotComp).GetUtf8Length(), 2 * lengthEcmaStrU16NotComp + 1);
352 }
353
354 /*
355 * @tc.name: ObjectSize
356 * @tc.desc: Check whether the value returned through calling ObjectSize function is within expectations.
357 * @tc.type: FUNC
358 * @tc.require:
359 */
HWTEST_F_L0(EcmaStringAccessorTest,ObjectSize)360 HWTEST_F_L0(EcmaStringAccessorTest, ObjectSize)
361 {
362 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateEmptyString(instance));
363 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).ObjectSize(), EcmaString::SIZE + 0);
364
365 size_t lengthEcmaStrAllocComp = 5;
366 JSHandle<EcmaString> handleEcmaStrAllocComp(thread,
367 EcmaStringAccessor::CreateLineString(instance, lengthEcmaStrAllocComp, true));
368 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocComp).ObjectSize(),
369 EcmaString::SIZE + sizeof(uint8_t) * lengthEcmaStrAllocComp);
370
371 size_t lengthEcmaStrAllocNotComp = 5;
372 JSHandle<EcmaString> handleEcmaStrAllocNotComp(thread,
373 EcmaStringAccessor::CreateLineString(instance, lengthEcmaStrAllocNotComp, false));
374 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocNotComp).ObjectSize(),
375 EcmaString::SIZE + sizeof(uint16_t) * lengthEcmaStrAllocNotComp);
376
377 uint8_t arrayU8[] = {"abcde"};
378 size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
379 JSHandle<EcmaString> handleEcmaStrU8(thread,
380 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
381 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).ObjectSize(), EcmaString::SIZE + sizeof(uint8_t) * lengthEcmaStrU8);
382
383 // ObjectSize(). EcmaString made by CreateFromUtf16( , , , true).
384 uint16_t arrayU16Comp[] = {1, 23, 45, 67, 127};
385 size_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
386 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
387 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
388 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16Comp).ObjectSize(),
389 EcmaString::SIZE + sizeof(uint8_t) * lengthEcmaStrU16Comp);
390
391 // ObjectSize(). EcmaString made by CreateFromUtf16( , , , false).
392 uint16_t arrayU16NotComp[] = {127, 128, 256, 11100, 65535};
393 size_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
394 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
395 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, false));
396 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16NotComp).ObjectSize(),
397 EcmaString::SIZE + sizeof(uint16_t) * lengthEcmaStrU16NotComp);
398 }
399
400 /*
401 * @tc.name: SetInternString
402 * @tc.desc: Call SetInternString function, check whether the bool returned through calling IsInternString function
403 * is within expectations.
404 * @tc.type: FUNC
405 * @tc.require:
406 */
HWTEST_F_L0(EcmaStringAccessorTest,SetInternString)407 HWTEST_F_L0(EcmaStringAccessorTest, SetInternString)
408 {
409 uint8_t arrayU8[] = {"abc"};
410 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
411 JSHandle<EcmaString> handleEcmaStrU8(thread,
412 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
413 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU8).IsInternString());
414 EcmaStringAccessor(handleEcmaStrU8).SetInternString();
415 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU8).IsInternString());
416
417 uint16_t arrayU16Comp[] = {97, 98, 99};
418 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
419 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
420 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
421 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU16Comp).IsInternString());
422 EcmaStringAccessor(handleEcmaStrU16Comp).SetInternString();
423 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU16Comp).IsInternString());
424
425 uint16_t arrayU16NotComp[] = {97, 98, 99};
426 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
427 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
428 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, true));
429 EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU16NotComp).IsInternString());
430 EcmaStringAccessor(handleEcmaStrU16NotComp).SetInternString();
431 EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU16NotComp).IsInternString());
432 }
433
434 /*
435 * @tc.name: GetDataUtf8
436 * @tc.desc: Check whether the pointer returned through calling GetDataUtf8 function is within expectations.
437 * @tc.type: FUNC
438 * @tc.require:
439 */
HWTEST_F_L0(EcmaStringAccessorTest,GetDataUtf8)440 HWTEST_F_L0(EcmaStringAccessorTest, GetDataUtf8)
441 {
442 // From EcmaString made by CreateFromUtf8().
443 uint8_t arrayU8[] = {"abcde"};
444 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
445 JSHandle<EcmaString> handleEcmaStrU8(thread,
446 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
447 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
448 EXPECT_EQ(*(EcmaStringAccessor(handleEcmaStrU8).GetDataUtf8() + i), arrayU8[i]);
449 }
450
451 // From EcmaString made by CreateFromUtf16( , , , true).
452 uint16_t arrayU16Comp[] = {3, 1, 34, 123, 127, 111, 42, 3, 20, 10};
453 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
454 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
455 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
456 for (uint32_t i = 0; i < sizeof(arrayU16Comp) / arrayU16Comp[0]; i++) {
457 EXPECT_EQ(*(EcmaStringAccessor(handleEcmaStrU16Comp).GetDataUtf8() + i), arrayU16Comp[i]);
458 }
459 }
460
461 /*
462 * @tc.name: GetDataUtf16
463 * @tc.desc: Check whether the pointer returned through calling GetDataUtf16 function is within expectations.
464 * @tc.type: FUNC
465 * @tc.require:
466 */
HWTEST_F_L0(EcmaStringAccessorTest,GetDataUtf16)467 HWTEST_F_L0(EcmaStringAccessorTest, GetDataUtf16)
468 {
469 // From EcmaString made by CreateFromUtf16( , , , false).
470 uint16_t arrayU16NotComp[] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333};
471 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
472 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
473 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, false));
474 for (uint32_t i = 0; i < lengthEcmaStrU16NotComp; i++) {
475 EXPECT_EQ(*(EcmaStringAccessor(handleEcmaStrU16NotComp).GetDataUtf16() + i), arrayU16NotComp[i]);
476 }
477 }
478
479 /*
480 * @tc.name: WriteToFlatUtf8
481 * @tc.desc: Check whether the returned value and the changed array through a source EcmaString's calling
482 * WriteToFlatUtf8 function are within expectations.
483 * @tc.type: FUNC
484 * @tc.require:
485 */
HWTEST_F_L0(EcmaStringAccessorTest,WriteToFlatUtf8)486 HWTEST_F_L0(EcmaStringAccessorTest, WriteToFlatUtf8)
487 {
488 // WriteToFlatUtf8(). From EcmaString made by CreateFromUtf8().
489 uint8_t arrayU8CopyFrom[6] = {1, 12, 34, 56, 127};
490 uint32_t lengthEcmaStrU8CopyFrom = sizeof(arrayU8CopyFrom) - 1;
491 JSHandle<EcmaString> handleEcmaStrU8CopyFrom(thread,
492 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8CopyFrom[0], lengthEcmaStrU8CopyFrom, true));
493 const size_t lengthArrayU8Target = 6;
494 uint8_t arrayU8CopyTo[lengthArrayU8Target];
495
496 size_t lengthReturnU8 = EcmaStringAccessor(handleEcmaStrU8CopyFrom)
497 .WriteToFlatUtf8(&arrayU8CopyTo[0], lengthArrayU8Target);
498
499 EXPECT_EQ(lengthReturnU8, lengthArrayU8Target);
500 for (uint32_t i = 0; i < lengthReturnU8 - 1; i++) {
501 EXPECT_EQ(arrayU8CopyTo[i], arrayU8CopyFrom[i]);
502 }
503 EXPECT_EQ(arrayU8CopyTo[lengthReturnU8 - 1], 0);
504
505 // CopyDataUtf8(). From EcmaString made by CreateFromUtf16( , , , true).
506 uint16_t arrayU16CompCopyFrom[] = {1, 12, 34, 56, 127};
507 uint32_t lengthEcmaStrU16CompCopyFrom = sizeof(arrayU16CompCopyFrom) / sizeof(arrayU16CompCopyFrom[0]);
508 JSHandle<EcmaString> handleEcmaStrU16CompCopyFrom(thread,
509 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompCopyFrom[0], lengthEcmaStrU16CompCopyFrom, true));
510 const size_t lengthArrayU16Target = 6;
511 uint8_t arrayU8CompCopyTo[lengthArrayU16Target];
512
513 size_t lengthReturnU16Comp = EcmaStringAccessor(handleEcmaStrU16CompCopyFrom)
514 .WriteToFlatUtf8(&arrayU8CompCopyTo[0], lengthArrayU16Target);
515
516 EXPECT_EQ(lengthReturnU16Comp, lengthArrayU16Target);
517 for (uint32_t i = 0; i < lengthReturnU16Comp - 1; i++) {
518 EXPECT_EQ(arrayU8CompCopyTo[i], arrayU16CompCopyFrom[i]);
519 }
520 EXPECT_EQ(arrayU8CompCopyTo[lengthReturnU16Comp - 1], 0U);
521
522 uint8_t buffer[200] = {0};
523 std::string str(
524 "您订单尾号为：1442的车辆提车点已由重庆市渝北区龙兴镇新能源办公大楼变更为重庆市江北区鱼嘴镇永和路39号2屋208室，请携带好相关材料按照预约时间前往提车点提车2,如有296ss");
525 JSHandle<EcmaString> ecmaStr = thread->GetEcmaVM()->GetFactory()->NewFromStdString(str);
526 uint32_t len = EcmaStringAccessor(ecmaStr).WriteToFlatUtf8(buffer, 198, true);
527 EXPECT_EQ(len, 197);
528 }
529
530 /*
531 * @tc.name: WriteToFlatUtf16
532 * @tc.desc: Check whether the returned value and the changed array through a source EcmaString's calling
533 * WriteToFlatUtf16 function are within expectations.
534 * @tc.type: FUNC
535 * @tc.require:
536 */
HWTEST_F_L0(EcmaStringAccessorTest,WriteToFlatUtf16)537 HWTEST_F_L0(EcmaStringAccessorTest, WriteToFlatUtf16)
538 {
539 // WriteToFlatUtf16(). From EcmaString made by CreateFromUtf16( , , , false).
540 uint16_t arrayU16NotCompCopyFrom[10] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333};
541 uint32_t lengthEcmaStrU16NotCompCopyFrom = sizeof(arrayU16NotCompCopyFrom) / sizeof(arrayU16NotCompCopyFrom[0]);
542 JSHandle<EcmaString> handleEcmaStrU16NotCompCopyFrom(thread, EcmaStringAccessor::CreateFromUtf16(
543 instance, &arrayU16NotCompCopyFrom[0], lengthEcmaStrU16NotCompCopyFrom, false));
544 const size_t lengthArrayU16Target = 13;
545 uint16_t arrayU16NotCompCopyTo[lengthArrayU16Target];
546 uint8_t defaultOneByteValueOfArrayU16NotCompCopyTo = 244;
547 int checkResUtf16 = memset_s(&arrayU16NotCompCopyTo[0], sizeof(uint16_t) * lengthArrayU16Target,
548 defaultOneByteValueOfArrayU16NotCompCopyTo, sizeof(uint16_t) * lengthArrayU16Target);
549 EXPECT_TRUE(checkResUtf16 == 0);
550
551 size_t lengthReturnU16NotComp = EcmaStringAccessor(handleEcmaStrU16NotCompCopyFrom)
552 .WriteToFlatUtf16(&arrayU16NotCompCopyTo[0], lengthArrayU16Target);
553
554 EXPECT_EQ(lengthReturnU16NotComp, lengthEcmaStrU16NotCompCopyFrom);
555 for (uint32_t i = 0; i < lengthReturnU16NotComp; i++) {
556 EXPECT_EQ(arrayU16NotCompCopyTo[i], EcmaStringAccessor(handleEcmaStrU16NotCompCopyFrom).Get(i));
557 }
558 for (uint32_t i = lengthReturnU16NotComp; i < lengthArrayU16Target; i++) {
559 EXPECT_EQ(arrayU16NotCompCopyTo[i], ((uint16_t)defaultOneByteValueOfArrayU16NotCompCopyTo) * (1 + (1 << 8)));
560 }
561 }
562
563 /*
564 * @tc.name: ReadData_001
565 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , true, ) changed through calling ReadData
566 * function with a source EcmaString made by CreateFromUtf8() is within expectations.
567 * @tc.type: FUNC
568 * @tc.require:
569 */
HWTEST_F_L0(EcmaStringAccessorTest,ReadData_001)570 HWTEST_F_L0(EcmaStringAccessorTest, ReadData_001)
571 {
572 // ReadData(). From EcmaString made by CreateFromUtf8() to EcmaString made by CreateLineString( , true, ).
573 uint8_t arrayU8WriteFrom[6] = {1, 12, 34, 56, 127};
574 uint32_t lengthEcmaStrU8WriteFrom = sizeof(arrayU8WriteFrom) - 1;
575 JSHandle<EcmaString> handleEcmaStrU8WriteFrom(thread,
576 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8WriteFrom[0], lengthEcmaStrU8WriteFrom, true));
577 size_t sizeEcmaStrU8WriteTo = 5;
578 JSHandle<EcmaString> handleEcmaStrAllocTrueWriteTo(thread,
579 EcmaStringAccessor::CreateLineString(instance, sizeEcmaStrU8WriteTo, true));
580 uint32_t indexStartWriteFromArrayU8 = 2;
581 uint32_t lengthWriteFromArrayU8 = 2;
582 EcmaStringAccessor::ReadData(*handleEcmaStrAllocTrueWriteTo, *handleEcmaStrU8WriteFrom, indexStartWriteFromArrayU8,
583 sizeEcmaStrU8WriteTo, lengthWriteFromArrayU8);
584 for (uint32_t i = 0; i < lengthWriteFromArrayU8; i++) {
585 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocTrueWriteTo).Get(i + indexStartWriteFromArrayU8),
586 EcmaStringAccessor(handleEcmaStrU8WriteFrom).Get(i));
587 }
588 }
589
590 /*
591 * @tc.name: ReadData_002
592 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , false, ) changed through calling
593 * ReadData function with a source EcmaString made by CreateFromUtf16( , , , false) is within expectations.
594 * @tc.type: FUNC
595 * @tc.require:
596 */
HWTEST_F_L0(EcmaStringAccessorTest,ReadData_002)597 HWTEST_F_L0(EcmaStringAccessorTest, ReadData_002)
598 {
599 /* ReadData(). From EcmaString made by CreateFromUtf16( , , , false) to EcmaStringU16 made by
600 * CreateLineString( , false, ).
601 */
602 uint16_t arrayU16WriteFrom[10] = {67, 777, 1999, 1, 45, 66, 23456, 65535, 127, 333};
603 uint32_t lengthEcmaStrU16WriteFrom = sizeof(arrayU16WriteFrom) / sizeof(arrayU16WriteFrom[0]);
604 JSHandle<EcmaString> handleEcmaStrU16WriteFrom(thread,
605 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16WriteFrom[0], lengthEcmaStrU16WriteFrom, false));
606 size_t sizeEcmaStrU16WriteTo = 10;
607 JSHandle<EcmaString> handleEcmaStrU16WriteTo(thread,
608 EcmaStringAccessor::CreateLineString(instance, sizeEcmaStrU16WriteTo, false));
609 uint32_t indexStartWriteFromArrayU16 = 3;
610 uint32_t numBytesWriteFromArrayU16 = 2 * 3;
611 EcmaStringAccessor::ReadData(*handleEcmaStrU16WriteTo, *handleEcmaStrU16WriteFrom, indexStartWriteFromArrayU16,
612 sizeEcmaStrU16WriteTo, numBytesWriteFromArrayU16);
613 for (uint32_t i = 0; i < (numBytesWriteFromArrayU16 / 2); i++) {
614 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16WriteTo).Get(i + indexStartWriteFromArrayU16),
615 EcmaStringAccessor(handleEcmaStrU16WriteFrom).Get(i));
616 }
617 }
618
619 /*
620 * @tc.name: ReadData_003
621 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , false, ) changed through calling
622 * ReadData function with a source EcmaString made by CreateFromUtf8() is within expectations.
623 * @tc.type: FUNC
624 * @tc.require:
625 */
HWTEST_F_L0(EcmaStringAccessorTest,ReadData_003)626 HWTEST_F_L0(EcmaStringAccessorTest, ReadData_003)
627 {
628 // ReadData(). From EcmaString made by CreateFromUtf8() to EcmaString made by CreateLineString( , false, ).
629 uint8_t arrayU8WriteFrom[6] = {1, 12, 34, 56, 127};
630 uint32_t lengthEcmaStrU8WriteFrom = sizeof(arrayU8WriteFrom) - 1;
631 JSHandle<EcmaString> handleEcmaStrU8WriteFrom(thread,
632 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8WriteFrom[0], lengthEcmaStrU8WriteFrom, true));
633 size_t sizeEcmaStrU16WriteTo = 10;
634 JSHandle<EcmaString> handleEcmaStrU16WriteTo(thread,
635 EcmaStringAccessor::CreateLineString(instance, sizeEcmaStrU16WriteTo, false));
636 uint32_t indexStartWriteFromU8ToU16 = 1;
637 uint32_t numBytesWriteFromU8ToU16 = 4;
638 EcmaStringAccessor::ReadData(*handleEcmaStrU16WriteTo, *handleEcmaStrU8WriteFrom,
639 indexStartWriteFromU8ToU16, sizeEcmaStrU16WriteTo,
640 numBytesWriteFromU8ToU16);
641 for (uint32_t i = 0; i < numBytesWriteFromU8ToU16; i++) {
642 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16WriteTo).Get(i + indexStartWriteFromU8ToU16),
643 EcmaStringAccessor(handleEcmaStrU8WriteFrom).Get(i));
644 }
645 }
646
647 /*
648 * @tc.name: Set_001
649 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , true, ) changed through calling Set
650 * function from a source char is within expectations.
651 * @tc.type: FUNC
652 * @tc.require:
653 */
HWTEST_F_L0(EcmaStringAccessorTest,Set_001)654 HWTEST_F_L0(EcmaStringAccessorTest, Set_001)
655 {
656 // Set(). From char to EcmaString made by CreateLineString( , true, ).
657 char u8Write = 'a';
658 size_t sizeEcmaStrU8WriteTo = 5;
659 JSHandle<EcmaString> handleEcmaStrAllocTrueWriteTo(thread,
660 EcmaStringAccessor::CreateLineString(instance, sizeEcmaStrU8WriteTo, true));
661 uint32_t indexAtWriteFromU8 = 4;
662 EcmaStringAccessor(handleEcmaStrAllocTrueWriteTo).Set(indexAtWriteFromU8, u8Write);
663 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrAllocTrueWriteTo).Get(indexAtWriteFromU8), u8Write);
664 }
665
666 /*
667 * @tc.name: Set_002
668 * @tc.desc: Check whether the target EcmaString made by CreateLineString( , false, ) changed through calling
669 * Set function with a source char is within expectations.
670 * @tc.type: FUNC
671 * @tc.require:
672 */
HWTEST_F_L0(EcmaStringAccessorTest,Set_002)673 HWTEST_F_L0(EcmaStringAccessorTest, Set_002)
674 {
675 // Set(). From char to EcmaString made by CreateLineString( , false, ).
676 size_t sizeEcmaStrU16WriteTo = 10;
677 JSHandle<EcmaString> handleEcmaStrU16WriteTo(thread,
678 EcmaStringAccessor::CreateLineString(instance, sizeEcmaStrU16WriteTo, false));
679 char u8Write = 'a';
680 uint32_t indexAt = 4;
681 EcmaStringAccessor(handleEcmaStrU16WriteTo).Set(indexAt, u8Write);
682 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16WriteTo).Get(indexAt), u8Write);
683 }
684
685 /*
686 * @tc.name: GetHashcode_001
687 * @tc.desc: Check whether the value returned through an EcmaString made by CreateFromUtf8() calling GetHashcode
688 * function is within expectations.
689 * @tc.type: FUNC
690 * @tc.require:
691 */
HWTEST_F_L0(EcmaStringAccessorTest,GetHashcode_001)692 HWTEST_F_L0(EcmaStringAccessorTest, GetHashcode_001)
693 {
694 // GetHashcode(). EcmaString made by CreateFromUtf8().
695 uint8_t arrayU8[] = {"abc"};
696 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
697 JSHandle<EcmaString> handleEcmaStrU8(thread,
698 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
699 uint32_t hashExpect = 0;
700 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
701 hashExpect = hashExpect * 31 + arrayU8[i];
702 }
703 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetHashcode(), hashExpect);
704 }
705
706 /*
707 * @tc.name: GetHashcode_002
708 * @tc.desc: Check whether the value returned through an EcmaString made by CreateFromUtf16( , , , true) calling
709 * GetHashcode function is within expectations.
710 * @tc.type: FUNC
711 * @tc.require:
712 */
HWTEST_F_L0(EcmaStringAccessorTest,GetHashcode_002)713 HWTEST_F_L0(EcmaStringAccessorTest, GetHashcode_002)
714 {
715 // GetHashcode(). EcmaString made by CreateFromUtf16( , , , true).
716 uint16_t arrayU16Comp[] = {45, 92, 78, 24};
717 uint32_t lengthEcmaStrU16Comp = sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0]);
718 JSHandle<EcmaString> handleEcmaStrU16Comp(thread,
719 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16Comp[0], lengthEcmaStrU16Comp, true));
720 uint32_t hashExpect = 0;
721 for (uint32_t i = 0; i < lengthEcmaStrU16Comp; i++) {
722 hashExpect = hashExpect * 31 + arrayU16Comp[i];
723 }
724 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16Comp).GetHashcode(), hashExpect);
725 }
726
727 /*
728 * @tc.name: GetHashcode_003
729 * @tc.desc: Check whether the value returned through an EcmaString made by CreateFromUtf16( , , , false) calling
730 * GetHashcode function is within expectations.
731 * @tc.type: FUNC
732 * @tc.require:
733 */
HWTEST_F_L0(EcmaStringAccessorTest,GetHashcode_003)734 HWTEST_F_L0(EcmaStringAccessorTest, GetHashcode_003)
735 {
736 // GetHashcode(). EcmaString made by CreateFromUtf16( , , , false).
737 uint16_t arrayU16NotComp[] = {199, 1, 256, 65535, 777};
738 uint32_t lengthEcmaStrU16NotComp = sizeof(arrayU16NotComp) / sizeof(arrayU16NotComp[0]);
739 JSHandle<EcmaString> handleEcmaStrU16NotComp(thread,
740 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotComp[0], lengthEcmaStrU16NotComp, false));
741 uint32_t hashExpect = 0;
742 for (uint32_t i = 0; i < lengthEcmaStrU16NotComp; i++) {
743 hashExpect = hashExpect * 31 + arrayU16NotComp[i];
744 }
745 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU16NotComp).GetHashcode(), hashExpect);
746 }
747
748 /*
749 * @tc.name: GetHashcode_004
750 * @tc.desc: Check whether the value returned through an EcmaString made by CreateEmptyString() calling GetHashcode
751 * function is within expectations.
752 * @tc.type: FUNC
753 * @tc.require:
754 */
HWTEST_F_L0(EcmaStringAccessorTest,GetHashcode_004)755 HWTEST_F_L0(EcmaStringAccessorTest, GetHashcode_004)
756 {
757 // GetHashcode(). EcmaString made by CreateEmptyString().
758 JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateEmptyString(instance));
759 EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).GetHashcode(), 0U);
760 }
761
762 /*
763 * @tc.name: ComputeHashcodeUtf8
764 * @tc.desc: Check whether the value returned through calling ComputeHashcodeUtf8 function with an Array(uint8_t) is
765 * within expectations.
766 * @tc.type: FUNC
767 * @tc.require:
768 */
HWTEST_F_L0(EcmaStringAccessorTest,ComputeHashcodeUtf8)769 HWTEST_F_L0(EcmaStringAccessorTest, ComputeHashcodeUtf8)
770 {
771 uint8_t arrayU8[] = {"abc"};
772 uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
773 uint32_t hashExpect = 0;
774 for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
775 hashExpect = hashExpect * 31 + arrayU8[i];
776 }
777 EXPECT_EQ(EcmaStringAccessor::ComputeHashcodeUtf8(&arrayU8[0], lengthEcmaStrU8, true), hashExpect);
778 }
779
780 /*
781 * @tc.name: ComputeHashcodeUtf16
782 * @tc.desc: Check whether the value returned through calling ComputeHashcodeUtf16 function with an Array(uint16_t) is
783 * within expectations.
784 * @tc.type: FUNC
785 * @tc.require:
786 */
HWTEST_F_L0(EcmaStringAccessorTest,ComputeHashcodeUtf16)787 HWTEST_F_L0(EcmaStringAccessorTest, ComputeHashcodeUtf16)
788 {
789 uint16_t arrayU16[] = {199, 1, 256, 65535, 777};
790 uint32_t lengthEcmaStrU16 = sizeof(arrayU16) / sizeof(arrayU16[0]);
791 uint32_t hashExpect = 0;
792 for (uint32_t i = 0; i < lengthEcmaStrU16; i++) {
793 hashExpect = hashExpect * 31 + arrayU16[i];
794 }
795 EXPECT_EQ(EcmaStringAccessor::ComputeHashcodeUtf16(&arrayU16[0], lengthEcmaStrU16), hashExpect);
796 }
797
798 /*
799 * @tc.name: IndexOf_001
800 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateFromUtf8() calling IndexOf
801 * function with a target EcmaString made by CreateFromUtf8() is within expectations.
802 * @tc.type: FUNC
803 * @tc.require:
804 */
HWTEST_F_L0(EcmaStringAccessorTest,IndexOf_001)805 HWTEST_F_L0(EcmaStringAccessorTest, IndexOf_001)
806 {
807 // IndexOf(). Find EcmaString made by CreateFromUtf8() From EcmaString made by CreateFromUtf8().
808 uint8_t arrayU8From[7] = {23, 25, 1, 3, 39, 80};
809 uint8_t arrayU8Target[4] = {1, 3, 39};
810 uint32_t lengthEcmaStrU8From = sizeof(arrayU8From) - 1;
811 uint32_t lengthEcmaStrU8Target = sizeof(arrayU8Target) - 1;
812 JSHandle<EcmaString> handleEcmaStr(thread,
813 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8From[0], lengthEcmaStrU8From, true));
814 JSHandle<EcmaString> handleEcmaStr1(thread,
815 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8Target[0], lengthEcmaStrU8Target, true));
816 int32_t posStart = 0;
817 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
818 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), -1);
819 posStart = -1;
820 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
821 posStart = 1;
822 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
823 posStart = 2;
824 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
825 posStart = 3;
826 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), -1);
827 }
828
829 /*
830 * @tc.name: IndexOf_002
831 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateFromUtf16( , , , false) calling
832 * IndexOf function with a target EcmaString made by CreateFromUtf8() is within expectations.
833 * @tc.type: FUNC
834 * @tc.require:
835 */
HWTEST_F_L0(EcmaStringAccessorTest,IndexOf_002)836 HWTEST_F_L0(EcmaStringAccessorTest, IndexOf_002)
837 {
838 // IndexOf(). Find EcmaString made by CreateFromUtf8() From EcmaString made by CreateFromUtf16( , , , false).
839 uint8_t arrayU8Target[4] = {1, 3, 39};
840 uint16_t arrayU16NotCompFromNo1[] = {67, 65535, 127, 777, 1453, 44, 1, 3, 39, 80, 333};
841 uint32_t lengthEcmaStrU8Target = sizeof(arrayU8Target) - 1;
842 uint32_t lengthEcmaStrU16NotCompFromNo1 = sizeof(arrayU16NotCompFromNo1) / sizeof(arrayU16NotCompFromNo1[0]);
843 JSHandle<EcmaString> handleEcmaStr(thread,
844 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8Target[0], lengthEcmaStrU8Target, true));
845 JSHandle<EcmaString> handleEcmaStr1(thread, EcmaStringAccessor::CreateFromUtf16(
846 instance, &arrayU16NotCompFromNo1[0], lengthEcmaStrU16NotCompFromNo1, false));
847 int32_t posStart = 0;
848 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), 6);
849 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), -1);
850 posStart = -1;
851 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), 6);
852 posStart = 1;
853 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), 6);
854 posStart = 6;
855 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), 6);
856 posStart = 7;
857 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), -1);
858 }
859
860 /*
861 * @tc.name: IndexOf_003
862 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateFromUtf16( , , , false) calling
863 * IndexOf function with a target EcmaString made by CreateFromUtf16( , , , false) is within expectations.
864 * @tc.type: FUNC
865 * @tc.require:
866 */
HWTEST_F_L0(EcmaStringAccessorTest,IndexOf_003)867 HWTEST_F_L0(EcmaStringAccessorTest, IndexOf_003)
868 {
869 /* IndexOf(). Find EcmaString made by CreateFromUtf16( , , , false) From EcmaString made by
870 * CreateFromUtf16( , , , false).
871 */
872 uint16_t arrayU16NotCompTarget[] = {1453, 44};
873 uint16_t arrayU16NotCompFrom[] = {67, 65535, 127, 777, 1453, 44, 1, 3, 39, 80, 333};
874 uint32_t lengthEcmaStrU16NotCompTarget = sizeof(arrayU16NotCompTarget) / sizeof(arrayU16NotCompTarget[0]);
875 uint32_t lengthEcmaStrU16NotCompFrom = sizeof(arrayU16NotCompFrom) / sizeof(arrayU16NotCompFrom[0]);
876 JSHandle<EcmaString> handleEcmaStrU16NotCompTarget(thread, EcmaStringAccessor::CreateFromUtf16(
877 instance, &arrayU16NotCompTarget[0], lengthEcmaStrU16NotCompTarget, false));
878 JSHandle<EcmaString> handleEcmaStrU16NotCompFrom(thread,
879 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompFrom[0], lengthEcmaStrU16NotCompFrom, false));
880 int32_t posStart = 0;
881 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance,
882 handleEcmaStrU16NotCompFrom, handleEcmaStrU16NotCompTarget, posStart), 4);
883 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance,
884 handleEcmaStrU16NotCompTarget, handleEcmaStrU16NotCompFrom, posStart), -1);
885 posStart = -1;
886 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance,
887 handleEcmaStrU16NotCompFrom, handleEcmaStrU16NotCompTarget, posStart), 4);
888 posStart = 1;
889 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance,
890 handleEcmaStrU16NotCompFrom, handleEcmaStrU16NotCompTarget, posStart), 4);
891 posStart = 4;
892 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance,
893 handleEcmaStrU16NotCompFrom, handleEcmaStrU16NotCompTarget, posStart), 4);
894 posStart = 5;
895 EXPECT_EQ(EcmaStringAccessor::IndexOf(instance,
896 handleEcmaStrU16NotCompFrom, handleEcmaStrU16NotCompTarget, posStart), -1);
897 }
898
899 /*
900 * @tc.name: IndexOf_004
901 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateFromUtf8() calling IndexOf
902 * function with a target EcmaString made by CreateFromUtf16() is within expectations.
903 * @tc.type: FUNC
904 * @tc.require:
905 */
HWTEST_F_L0(EcmaStringAccessorTest,IndexOf_004)906 HWTEST_F_L0(EcmaStringAccessorTest, IndexOf_004)
907 {
908 // IndexOf(). Find EcmaString made by CreateFromUtf16() From EcmaString made by CreateFromUtf8().
909 std::vector<uint16_t> ecmaStrU16NotCompTarget = {3, 39, 80};
910 std::vector<uint8_t> arrayU8From{23, 25, 1, 3, 39, 80};
911 auto func = std::bind(EcmaStringAccessor::CreateFromUtf8, std::placeholders::_1, std::placeholders::_2,
912 std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, false, 0);
913 EcmaTestCommon::IndexOfCommonCase(thread, instance, ecmaStrU16NotCompTarget, arrayU8From, func);
914 }
915
916 /*
917 * @tc.name: Compare_001
918 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by
919 * CreateFromUtf8() is within expectations.
920 * @tc.type: FUNC
921 * @tc.require:
922 */
HWTEST_F_L0(EcmaStringAccessorTest,Compare_001)923 HWTEST_F_L0(EcmaStringAccessorTest, Compare_001)
924 {
925 // Compare(). Between EcmaStrings made by CreateFromUtf8().
926 uint8_t arrayU8No1[3] = {1, 23};
927 uint8_t arrayU8No2[4] = {1, 23, 49};
928 uint8_t arrayU8No3[6] = {1, 23, 45, 97, 127};
929 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
930 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
931 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
932 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
933 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
934 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
935 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
936 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
937 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
938 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU8No2), -1);
939 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No1), 1);
940 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No3), 49 - 45);
941 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No3, handleEcmaStrU8No2), 45 - 49);
942 }
943
944 /*
945 * @tc.name: Compare_002
946 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by
947 * CreateFromUtf16( , , , true) is within expectations.
948 * @tc.type: FUNC
949 * @tc.require:
950 */
HWTEST_F_L0(EcmaStringAccessorTest,Compare_002)951 HWTEST_F_L0(EcmaStringAccessorTest, Compare_002)
952 {
953 // Compare(). Between EcmaStrings made by CreateFromUtf16( , , , true).
954 uint16_t arrayU16CompNo1[] = {1, 23};
955 uint16_t arrayU16CompNo2[] = {1, 23, 49};
956 uint16_t arrayU16CompNo3[] = {1, 23, 45, 97, 127};
957 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]);
958 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
959 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
960 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread,
961 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true));
962 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
963 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
964 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
965 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
966 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU16CompNo2), -1);
967 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU16CompNo1), 1);
968 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU16CompNo3), 49 - 45);
969 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo3, handleEcmaStrU16CompNo2), 45 - 49);
970 }
971
972 /*
973 * @tc.name: Compare_003
974 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by
975 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , true) made by CreateFromUtf16( , , , true) is within
976 * expectations.
977 * @tc.type: FUNC
978 * @tc.require:
979 */
HWTEST_F_L0(EcmaStringAccessorTest,Compare_003)980 HWTEST_F_L0(EcmaStringAccessorTest, Compare_003)
981 {
982 auto createUtf8 = std::bind(EcmaStringAccessor::CreateFromUtf8, std::placeholders::_1, std::placeholders::_2,
983 std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, false, 0);
984 auto createUtf16 = std::bind(EcmaStringAccessor::CreateFromUtf16, std::placeholders::_1, std::placeholders::_2,
985 std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE);
986 EcmaTestCommon::CompareCommonCase(thread, instance, createUtf8, createUtf16, EcmaStringAccessor::Compare);
987 }
988
989 /*
990 * @tc.name: Compare_004
991 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by
992 * CreateFromUtf16( , , , false) is within expectations.
993 * @tc.type: FUNC
994 * @tc.require:
995 */
HWTEST_F_L0(EcmaStringAccessorTest,Compare_004)996 HWTEST_F_L0(EcmaStringAccessorTest, Compare_004)
997 {
998 // Compare(). Between EcmaStrings made by CreateFromUtf16( , , , false).
999 uint16_t arrayU16NotCompNo1[] = {1, 23};
1000 uint16_t arrayU16NotCompNo2[] = {1, 23, 49};
1001 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127};
1002 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1003 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
1004 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
1005 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1006 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
1007 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
1008 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, true));
1009 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
1010 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
1011 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU16NotCompNo2), -1);
1012 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU16NotCompNo1), 1);
1013 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU16NotCompNo3), 49 - 456);
1014 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU16NotCompNo2), 456 - 49);
1015 }
1016
1017 /*
1018 * @tc.name: Compare_005
1019 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by
1020 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 */
HWTEST_F_L0(EcmaStringAccessorTest,Compare_005)1024 HWTEST_F_L0(EcmaStringAccessorTest, Compare_005)
1025 {
1026 // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false).
1027 uint8_t arrayU8No1[3] = {1, 23};
1028 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1029 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
1030 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1031
1032 uint8_t arrayU8No2[4] = {1, 23, 49};
1033 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
1034 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
1035 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
1036
1037 uint16_t arrayU16NotCompNo1[] = {1, 23};
1038 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1039 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1040 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
1041 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo1), 0);
1042 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU8No1), 0);
1043
1044 uint16_t arrayU16NotCompNo2[] = {1, 23, 49};
1045 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
1046 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
1047 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, true));
1048 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo2), -1);
1049 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU8No1), 1);
1050
1051 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127};
1052 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
1053 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
1054 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
1055 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU16NotCompNo3), 49 - 456);
1056 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU8No2), 456 - 49);
1057 }
1058
1059 /*
1060 * @tc.name: Compare_006
1061 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by
1062 * CreateFromUtf16( , , , true) and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
1063 * @tc.type: FUNC
1064 * @tc.require:
1065 */
HWTEST_F_L0(EcmaStringAccessorTest,Compare_006)1066 HWTEST_F_L0(EcmaStringAccessorTest, Compare_006)
1067 {
1068 // Compare(). EcmaString made by CreateFromUtf16( , , , true) and EcmaString made by CreateFromUtf16( , , , false).
1069 uint16_t arrayU16CompNo1[] = {1, 23};
1070 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]);
1071 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread,
1072 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true));
1073
1074 uint16_t arrayU16CompNo2[] = {1, 23, 49};
1075 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
1076 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
1077 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
1078
1079 uint16_t arrayU16NotCompNo1[] = {1, 23};
1080 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1081 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1082 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
1083
1084 uint16_t arrayU16NotCompNo2[] = {1, 23, 49};
1085 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
1086 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
1087 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, true));
1088
1089 uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127};
1090 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
1091 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
1092 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
1093
1094 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU16NotCompNo1), 0);
1095 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU16CompNo1), 0);
1096 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo1, handleEcmaStrU16NotCompNo2), -1);
1097 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU16CompNo1), 1);
1098 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16CompNo2, handleEcmaStrU16NotCompNo3), 49 - 456);
1099 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU16CompNo2), 456 - 49);
1100 }
1101
1102 /*
1103 * @tc.name: StringsAreEqual_001
1104 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by
1105 * CreateFromUtf8() is within expectations.
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqual_001)1109 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqual_001)
1110 {
1111 // StringsAreEqual().
1112 uint8_t arrayU8No1[4] = {45, 92, 78};
1113 uint8_t arrayU8No2[4] = {45, 92, 78};
1114 uint8_t arrayU8No3[5] = {45, 92, 78, 1};
1115 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1116 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
1117 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
1118 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
1119 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1120 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
1121 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
1122 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
1123 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
1124 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU8No2));
1125 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU8No3));
1126 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No3, *handleEcmaStrU8No1));
1127 }
1128
1129 /*
1130 * @tc.name: StringsAreEqual_002
1131 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by
1132 * CreateFromUtf8() and a EcmaString made by CreateFromUtf16(, , , true) is within expectations.
1133 * @tc.type: FUNC
1134 * @tc.require:
1135 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqual_002)1136 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqual_002)
1137 {
1138 // StringsAreEqual().
1139 uint8_t arrayU8No1[4] = {45, 92, 78};
1140 uint16_t arrayU16CompNo2[] = {45, 92, 78};
1141 uint16_t arrayU16CompNo3[] = {45, 92, 78, 1};
1142 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1143 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
1144 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
1145 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
1146 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1147 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
1148 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
1149 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
1150 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
1151 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16CompNo2));
1152 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16CompNo3));
1153 }
1154
1155 /*
1156 * @tc.name: StringsAreEqual_003
1157 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by
1158 * CreateFromUtf16(, , , true) is within expectations.
1159 * @tc.type: FUNC
1160 * @tc.require:
1161 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqual_003)1162 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqual_003)
1163 {
1164 // StringsAreEqual().
1165 uint16_t arrayU16CompNo1[] = {45, 92, 78};
1166 uint16_t arrayU16CompNo2[] = {45, 92, 78};
1167 uint16_t arrayU16CompNo3[] = {45, 92, 78, 1};
1168 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]);
1169 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
1170 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
1171 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread,
1172 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true));
1173 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
1174 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
1175 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
1176 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
1177 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16CompNo1, *handleEcmaStrU16CompNo2));
1178 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16CompNo1, *handleEcmaStrU16CompNo3));
1179 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16CompNo3, *handleEcmaStrU16CompNo1));
1180 }
1181
1182 /*
1183 * @tc.name: StringsAreEqual_004
1184 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by
1185 * CreateFromUtf8() and a EcmaString made by CreateFromUtf16(, , , false) is within expectations.
1186 * @tc.type: FUNC
1187 * @tc.require:
1188 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqual_004)1189 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqual_004)
1190 {
1191 // StringsAreEqual().
1192 uint8_t arrayU8No1[4] = {45, 92, 78};
1193 uint16_t arrayU16NotCompNo1[] = {45, 92, 78};
1194 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1195 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1196 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
1197 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1198 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1199 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
1200 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16NotCompNo1));
1201 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16NotCompNo1, *handleEcmaStrU8No1));
1202 }
1203
1204 /*
1205 * @tc.name: StringsAreEqual_005
1206 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by
1207 * CreateFromUtf16(, , , true) and a EcmaString made by CreateFromUtf16(, , , false) is within expectations.
1208 * @tc.type: FUNC
1209 * @tc.require:
1210 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqual_005)1211 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqual_005)
1212 {
1213 // StringsAreEqual().
1214 uint16_t arrayU16CompNo1[] = {45, 92, 78};
1215 uint16_t arrayU16NotCompNo1[] = {45, 92, 78};
1216 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]);
1217 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1218 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread,
1219 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true));
1220 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1221 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
1222 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16CompNo1, *handleEcmaStrU16NotCompNo1));
1223 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16NotCompNo1, *handleEcmaStrU16CompNo1));
1224 }
1225
1226 /*
1227 * @tc.name: StringsAreEqual_006
1228 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by
1229 * CreateFromUtf16(, , , false) is within expectations.
1230 * @tc.type: FUNC
1231 * @tc.require:
1232 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqual_006)1233 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqual_006)
1234 {
1235 // StringsAreEqual().
1236 uint16_t arrayU16NotCompNo1[] = {234, 345, 127, 2345, 65535, 5};
1237 uint16_t arrayU16NotCompNo2[] = {234, 345, 127, 2345, 65535, 5};
1238 uint16_t arrayU16NotCompNo3[] = {1, 234, 345, 127, 2345, 65535, 5};
1239 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1240 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
1241 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
1242 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1243 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, false));
1244 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
1245 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, false));
1246 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
1247 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
1248 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16NotCompNo1, *handleEcmaStrU16NotCompNo2));
1249 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16NotCompNo1, *handleEcmaStrU16NotCompNo3));
1250 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU16NotCompNo3, *handleEcmaStrU16NotCompNo1));
1251 }
1252
1253 /*
1254 * @tc.name: StringsAreEqualUtf8_001
1255 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made by
1256 * CreateFromUtf8() and an Array(uint8_t) is within expectations.
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqualUtf8_001)1260 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqualUtf8_001)
1261 {
1262 // StringIsEqualUint8Data(). EcmaString made by CreateFromUtf8(), Array:U8.
1263 uint8_t arrayU8No1[4] = {45, 92, 78};
1264 uint8_t arrayU8No2[5] = {45, 92, 78, 24};
1265 uint8_t arrayU8No3[3] = {45, 92};
1266 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1267 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
1268 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
1269 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
1270 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1271 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
1272 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
1273 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
1274 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
1275 EXPECT_TRUE(EcmaStringAccessor::StringIsEqualUint8Data(
1276 *handleEcmaStrU8No1, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1277 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(
1278 *handleEcmaStrU8No1, &arrayU8No1[0], lengthEcmaStrU8No1, false));
1279 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(
1280 *handleEcmaStrU8No2, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1281 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(
1282 *handleEcmaStrU8No3, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1283 }
1284
1285 /*
1286 * @tc.name: StringsAreEqualUtf8_002
1287 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made by
1288 * CreateFromUtf16( , , , true) and an Array(uint8_t) is within expectations.
1289 * @tc.type: FUNC
1290 * @tc.require:
1291 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqualUtf8_002)1292 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqualUtf8_002)
1293 {
1294 // StringIsEqualUint8Data(). EcmaString made by CreateFromUtf16( , , , true), Array:U8.
1295 uint8_t arrayU8No1[4] = {45, 92, 78};
1296 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1297
1298 uint16_t arrayU16CompNo1[] = {45, 92, 78};
1299 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]);
1300
1301 uint16_t arrayU16CompNo2[] = {45, 92, 78, 24};
1302 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
1303
1304 uint16_t arrayU16CompNo3[] = {45, 92};
1305 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
1306 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread,
1307 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true));
1308 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
1309 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
1310 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
1311 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
1312 EXPECT_TRUE(EcmaStringAccessor::StringIsEqualUint8Data(
1313 *handleEcmaStrU16CompNo1, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1314 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(
1315 *handleEcmaStrU16CompNo1, &arrayU8No1[0], lengthEcmaStrU8No1, false));
1316 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(
1317 *handleEcmaStrU16CompNo2, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1318 EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(
1319 *handleEcmaStrU16CompNo3, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1320 }
1321
1322 /*
1323 * @tc.name: StringsAreEqualUtf8_003
1324 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made by
1325 * CreateFromUtf16( , , , false) and an Array(uint8_t) is within expectations.
1326 * @tc.type: FUNC
1327 * @tc.require:
1328 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqualUtf8_003)1329 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqualUtf8_003)
1330 {
1331 // StringIsEqualUint8Data(). EcmaString made by CreateFromUtf16( , , , false), Array:U8.
1332 EcmaTestCommon::StringIsEqualCommonCase(thread, instance, EcmaStringAccessor::StringIsEqualUint8Data);
1333 }
1334
1335 /*
1336 * @tc.name: StringsAreEqualUtf16_001
1337 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made by
1338 * CreateFromUtf8() and an Array(uint16_t) is within expectations.
1339 * @tc.type: FUNC
1340 * @tc.require:
1341 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqualUtf16_001)1342 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqualUtf16_001)
1343 {
1344 // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf8, Array:U16(1-127).
1345 uint8_t arrayU8No1[4] = {45, 92, 78};
1346 uint8_t arrayU8No2[5] = {45, 92, 78, 24};
1347 uint8_t arrayU8No3[3] = {45, 92};
1348 uint16_t arrayU16NotCompNo1[] = {45, 92, 78};
1349 uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
1350 uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
1351 uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
1352 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1353 JSHandle<EcmaString> handleEcmaStrU8No1(thread,
1354 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
1355 JSHandle<EcmaString> handleEcmaStrU8No2(thread,
1356 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
1357 JSHandle<EcmaString> handleEcmaStrU8No3(thread,
1358 EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
1359 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqualUtf16(
1360 *handleEcmaStrU8No1, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
1361 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(
1362 *handleEcmaStrU8No2, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
1363 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(
1364 *handleEcmaStrU8No3, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
1365 }
1366
1367 /*
1368 * @tc.name: StringsAreEqualUtf16_002
1369 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made by
1370 * CreateFromUtf16( , , , true) and an Array(uint16_t) is within expectations.
1371 * @tc.type: FUNC
1372 * @tc.require:
1373 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqualUtf16_002)1374 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqualUtf16_002)
1375 {
1376 // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf16( , , , true), Array:U16(1-127).
1377 uint16_t arrayU16CompNo1[] = {45, 92, 78};
1378 uint32_t lengthEcmaStrU16CompNo1 = sizeof(arrayU16CompNo1) / sizeof(arrayU16CompNo1[0]);
1379 JSHandle<EcmaString> handleEcmaStrU16CompNo1(thread,
1380 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1, true));
1381
1382 uint16_t arrayU16CompNo2[] = {45, 92, 78, 24};
1383 uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
1384 JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
1385 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
1386
1387 uint16_t arrayU16CompNo3[] = {45, 92};
1388 uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
1389 JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
1390 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
1391
1392 uint16_t arrayU16CompNo4[] = {25645, 25692, 25678}; // 25645 % 256 == 45...
1393 uint32_t lengthEcmaStrU16CompNo4 = sizeof(arrayU16CompNo4) / sizeof(arrayU16CompNo4[0]);
1394 JSHandle<EcmaString> handleEcmaStrU16CompNo4(thread,
1395 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo4[0], lengthEcmaStrU16CompNo4, true));
1396
1397 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqualUtf16(
1398 *handleEcmaStrU16CompNo1, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1));
1399 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(
1400 *handleEcmaStrU16CompNo2, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1));
1401 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(
1402 *handleEcmaStrU16CompNo3, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1));
1403 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqualUtf16(
1404 *handleEcmaStrU16CompNo4, &arrayU16CompNo1[0], lengthEcmaStrU16CompNo1));
1405 }
1406
1407 /*
1408 * @tc.name: StringsAreEqualUtf16_003
1409 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made by
1410 * CreateFromUtf16( , , , false) and an Array(uint16_t) is within expectations.
1411 * @tc.type: FUNC
1412 * @tc.require:
1413 */
HWTEST_F_L0(EcmaStringAccessorTest,StringsAreEqualUtf16_003)1414 HWTEST_F_L0(EcmaStringAccessorTest, StringsAreEqualUtf16_003)
1415 {
1416 // StringsAreEqualUtf16(). EcmaString made by CreateFromUtf16( , , , false), Array:U16(0-65535).
1417 uint16_t arrayU16NotCompNo1[] = {25645, 25692, 25678};
1418 uint16_t arrayU16NotCompNo2[] = {25645, 25692, 78}; // 25645 % 256 == 45...
1419 uint16_t arrayU16NotCompNo3[] = {25645, 25692, 25678, 65535};
1420 uint16_t arrayU16NotCompNo4[] = {25645, 25692};
1421 uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
1422 uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
1423 uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
1424 uint32_t lengthEcmaStrU16NotCompNo4 = sizeof(arrayU16NotCompNo4) / sizeof(arrayU16NotCompNo4[0]);
1425 JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
1426 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, false));
1427 JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
1428 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, false));
1429 JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
1430 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
1431 JSHandle<EcmaString> handleEcmaStrU16NotCompNo4(thread,
1432 EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo4[0], lengthEcmaStrU16NotCompNo4, false));
1433 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU16NotCompNo1, &arrayU16NotCompNo1[0],
1434 lengthEcmaStrU16NotCompNo1));
1435 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU16NotCompNo1, &arrayU16NotCompNo2[0],
1436 lengthEcmaStrU16NotCompNo2));
1437 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU16NotCompNo2, &arrayU16NotCompNo1[0],
1438 lengthEcmaStrU16NotCompNo1));
1439 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU16NotCompNo3, &arrayU16NotCompNo1[0],
1440 lengthEcmaStrU16NotCompNo1));
1441 EXPECT_FALSE(EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU16NotCompNo4, &arrayU16NotCompNo1[0],
1442 lengthEcmaStrU16NotCompNo1));
1443 }
1444
1445 /*
1446 * @tc.name: EqualToSplicedString_001
1447 * @tc.desc: Tests whether the source string is equal to the concatenated string.
1448 * is within expectations.
1449 * @tc.type: FUNC
1450 * @tc.require:
1451 */
HWTEST_F_L0(EcmaStringAccessorTest,EqualToSplicedString_001)1452 HWTEST_F_L0(EcmaStringAccessorTest, EqualToSplicedString_001)
1453 {
1454 ObjectFactory* factory = instance->GetFactory();
1455 {
1456 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始");
1457 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start");
1458 JSHandle<EcmaString> secondString = factory->NewFromUtf8("开始");
1459 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
1460 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
1461 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf16());
1462 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1463 EXPECT_TRUE(result);
1464 }
1465
1466 {
1467 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始");
1468 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start");
1469 JSHandle<EcmaString> secondString = factory->NewFromASCII("start");
1470 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
1471 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
1472 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf8());
1473 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1474 EXPECT_TRUE(!result);
1475 }
1476
1477 {
1478 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始");
1479 JSHandle<EcmaString> firstString = factory->NewFromUtf8("Start开");
1480 JSHandle<EcmaString> secondString = factory->NewFromUtf8("始");
1481 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
1482 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf16());
1483 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf16());
1484 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1485 EXPECT_TRUE(result);
1486 }
1487
1488 {
1489 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Startstart");
1490 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start");
1491 JSHandle<EcmaString> secondString = factory->NewFromASCII("start");
1492 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf8());
1493 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
1494 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf8());
1495 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1496 EXPECT_TRUE(result);
1497 }
1498
1499 {
1500 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Startstart");
1501 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start");
1502 JSHandle<EcmaString> secondString = factory->NewFromUtf8("开始");
1503 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf8());
1504 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
1505 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf16());
1506 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1507 EXPECT_TRUE(!result);
1508 }
1509
1510 {
1511 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Startstat");
1512 JSHandle<EcmaString> firstString = factory->NewFromASCII("Start");
1513 JSHandle<EcmaString> secondString = factory->NewFromASCII("start");
1514 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf8());
1515 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
1516 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf8());
1517 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1518 EXPECT_TRUE(!result);
1519 }
1520
1521 {
1522 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始");
1523 JSHandle<EcmaString> firstString = factory->NewFromUtf8("Stat开");
1524 JSHandle<EcmaString> secondString = factory->NewFromUtf8("始");
1525 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
1526 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf16());
1527 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf16());
1528 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1529 EXPECT_TRUE(!result);
1530 }
1531
1532 {
1533 JSHandle<EcmaString> sourceString = factory->NewFromUtf8("Start开始");
1534 JSHandle<EcmaString> firstString = factory->NewFromASCII("Stat");
1535 JSHandle<EcmaString> secondString = factory->NewFromUtf8("开始");
1536 EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf16());
1537 EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
1538 EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf16());
1539 bool result = EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
1540 EXPECT_TRUE(!result);
1541 }
1542 }
1543
1544 /*
1545 * @tc.name: EqualToSplicedString_002
1546 * @tc.desc: Tests whether the source string is equal to the concatenated string.
1547 * is within expectations.
1548 * @tc.type: FUNC
1549 * @tc.require:
1550 */
HWTEST_F_L0(EcmaStringAccessorTest,EqualToSplicedString_002)1551 HWTEST_F_L0(EcmaStringAccessorTest, EqualToSplicedString_002)
1552 {
1553 ObjectFactory* factory = instance->GetFactory();
1554 {
1555 JSHandle<EcmaString> allString = factory->NewFromUtf8("123A");
1556 JSHandle<EcmaString> firstString = factory->NewFromUtf8("123");
1557 JSHandle<EcmaString> secondString = factory->NewFromUtf8("A");
1558 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1559 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1560 EXPECT_TRUE(result);
1561 }
1562
1563 {
1564 JSHandle<EcmaString> allString = factory->NewFromUtf8("A123");
1565 JSHandle<EcmaString> firstString = factory->NewFromUtf8("A");
1566 JSHandle<EcmaString> secondString = factory->NewFromUtf8("123");
1567 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1568 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1569 EXPECT_TRUE(result);
1570 }
1571
1572 {
1573 JSHandle<EcmaString> allString = factory->NewFromUtf8("123456789A");
1574 JSHandle<EcmaString> firstString = factory->NewFromUtf8("123456789");
1575 JSHandle<EcmaString> secondString = factory->NewFromUtf8("A");
1576 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1577 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1578 EXPECT_TRUE(result);
1579 }
1580
1581 {
1582 JSHandle<EcmaString> allString = factory->NewFromUtf8("123456789011A");
1583 JSHandle<EcmaString> firstString = factory->NewFromUtf8("123456789011");
1584 JSHandle<EcmaString> secondString = factory->NewFromUtf8("A");
1585 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1586 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1587 EXPECT_TRUE(result);
1588 }
1589 }
1590
1591 /*
1592 * @tc.name: EqualToSplicedString_003
1593 * @tc.desc: Tests whether the source string is equal to the concatenated string.
1594 * is within expectations.
1595 * @tc.type: FUNC
1596 * @tc.require:
1597 */
HWTEST_F_L0(EcmaStringAccessorTest,EqualToSplicedString_003)1598 HWTEST_F_L0(EcmaStringAccessorTest, EqualToSplicedString_003)
1599 {
1600 ObjectFactory* factory = instance->GetFactory();
1601 {
1602 JSHandle<EcmaString> allString = factory->NewFromUtf8("12345678901");
1603 JSHandle<EcmaString> firstString = factory->NewFromUtf8("123456789");
1604 JSHandle<EcmaString> secondString = factory->NewFromUtf8("01");
1605 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1606 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1607 EXPECT_TRUE(result);
1608 }
1609
1610 {
1611 JSHandle<EcmaString> allString = factory->NewFromUtf8("12345678901");
1612 JSHandle<EcmaString> firstString = factory->NewFromUtf8("1234567890");
1613 JSHandle<EcmaString> secondString = factory->NewFromUtf8("1");
1614 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1615 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1616 EXPECT_TRUE(result);
1617 }
1618
1619 {
1620 JSHandle<EcmaString> allString = factory->NewFromUtf8("12345678901");
1621 JSHandle<EcmaString> firstString = factory->NewFromUtf8("123456789");
1622 JSHandle<EcmaString> secondString = factory->NewFromUtf8("01");
1623 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1624 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1625 EXPECT_TRUE(result);
1626 }
1627
1628 {
1629 JSHandle<EcmaString> allString = factory->NewFromUtf8("12345678901");
1630 JSHandle<EcmaString> firstString = factory->NewFromUtf8("12345678");
1631 JSHandle<EcmaString> secondString = factory->NewFromUtf8("901");
1632 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1633 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1634 EXPECT_TRUE(result);
1635 }
1636
1637 {
1638 JSHandle<EcmaString> allString = factory->NewFromUtf8("12345678901");
1639 JSHandle<EcmaString> firstString = factory->NewFromUtf8("1234567");
1640 JSHandle<EcmaString> secondString = factory->NewFromUtf8("8901");
1641 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1642 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1643 EXPECT_TRUE(result);
1644 }
1645
1646 {
1647 JSHandle<EcmaString> allString = factory->NewFromUtf8("123456789");
1648 JSHandle<EcmaString> firstString = factory->NewFromUtf8("12345");
1649 JSHandle<EcmaString> secondString = factory->NewFromUtf8("6789");
1650 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1651 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1652 EXPECT_TRUE(result);
1653 }
1654
1655 {
1656 JSHandle<EcmaString> allString = factory->NewFromUtf8("123456789");
1657 JSHandle<EcmaString> firstString = factory->NewFromUtf8("1234");
1658 JSHandle<EcmaString> secondString = factory->NewFromUtf8("56789");
1659 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1660 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1661 EXPECT_TRUE(result);
1662 }
1663 }
1664
1665 /*
1666 * @tc.name: EqualToSplicedString_004
1667 * @tc.desc: Tests whether the source string is equal to the concatenated string.
1668 * is within expectations.
1669 * @tc.type: FUNC
1670 * @tc.require:
1671 */
1672
HWTEST_F_L0(EcmaStringAccessorTest,EqualToSplicedString_004)1673 HWTEST_F_L0(EcmaStringAccessorTest, EqualToSplicedString_004)
1674 {
1675 ObjectFactory* factory = instance->GetFactory();
1676 {
1677 JSHandle<EcmaString> allString = factory->NewFromUtf8("你好在干嘛");
1678 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你好");
1679 JSHandle<EcmaString> secondString = factory->NewFromUtf8("在干嘛");
1680 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1681 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1682 EXPECT_TRUE(result);
1683 }
1684
1685 {
1686 JSHandle<EcmaString> allString = factory->NewFromUtf8("你吃饭了么");
1687 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你吃");
1688 JSHandle<EcmaString> secondString = factory->NewFromUtf8("饭了么");
1689 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1690 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1691 EXPECT_TRUE(result);
1692 }
1693
1694 {
1695 JSHandle<EcmaString> allString = factory->NewFromUtf8("你你你你你你你你你我我我我我我我我我");
1696 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你你你你你你你你你");
1697 JSHandle<EcmaString> secondString = factory->NewFromUtf8("我我我我我我我我我");
1698 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1699 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1700 EXPECT_TRUE(result);
1701 }
1702 }
1703
1704 /*
1705 * @tc.name: EqualToSplicedString_005
1706 * @tc.desc: Tests whether the source string is equal to the concatenated string.
1707 * is within expectations.
1708 * @tc.type: FUNC
1709 * @tc.require:
1710 */
HWTEST_F_L0(EcmaStringAccessorTest,EqualToSplicedString_005)1711 HWTEST_F_L0(EcmaStringAccessorTest, EqualToSplicedString_005)
1712 {
1713 ObjectFactory* factory = instance->GetFactory();
1714 {
1715 JSHandle<EcmaString> allString = factory->NewFromUtf8("你好233");
1716 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你");
1717 JSHandle<EcmaString> secondString = factory->NewFromUtf8("好233");
1718 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1719 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1720 EXPECT_TRUE(result);
1721 }
1722
1723 {
1724 JSHandle<EcmaString> allString = factory->NewFromUtf8("你好abc");
1725 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你好");
1726 JSHandle<EcmaString> secondString = factory->NewFromUtf8("abc");
1727 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1728 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1729 EXPECT_TRUE(result);
1730 }
1731
1732 {
1733 JSHandle<EcmaString> allString = factory->NewFromUtf8("233你好");
1734 JSHandle<EcmaString> firstString = factory->NewFromUtf8("233");
1735 JSHandle<EcmaString> secondString = factory->NewFromUtf8("你好");
1736 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1737 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1738 EXPECT_TRUE(result);
1739 }
1740
1741 {
1742 JSHandle<EcmaString> allString = factory->NewFromUtf8("abc你好");
1743 JSHandle<EcmaString> firstString = factory->NewFromUtf8("abc");
1744 JSHandle<EcmaString> secondString = factory->NewFromUtf8("你好");
1745 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1746 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1747 EXPECT_TRUE(result);
1748 }
1749
1750 {
1751 JSHandle<EcmaString> allString = factory->NewFromUtf8("你吃饭了么abc");
1752 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你吃");
1753 JSHandle<EcmaString> secondString = factory->NewFromUtf8("饭了么abc");
1754 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1755 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1756 EXPECT_TRUE(result);
1757 }
1758
1759 {
1760 JSHandle<EcmaString> allString = factory->NewFromUtf8("你吃饭了么abc");
1761 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你吃饭了么");
1762 JSHandle<EcmaString> secondString = factory->NewFromUtf8("abc");
1763 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1764 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1765 EXPECT_TRUE(result);
1766 }
1767 }
1768
1769 /*
1770 * @tc.name: EqualToSplicedString_006
1771 * @tc.desc: Tests whether the source string is equal to the concatenated string.
1772 * is within expectations.
1773 * @tc.type: FUNC
1774 * @tc.require:
1775 */
HWTEST_F_L0(EcmaStringAccessorTest,EqualToSplicedString_006)1776 HWTEST_F_L0(EcmaStringAccessorTest, EqualToSplicedString_006)
1777 {
1778 ObjectFactory* factory = instance->GetFactory();
1779 {
1780 JSHandle<EcmaString> allString = factory->NewFromUtf8("你好");
1781 JSHandle<EcmaString> firstString = factory->NewFromUtf8("你好");
1782 JSHandle<EcmaString> secondString = factory->NewFromUtf8("");
1783 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1784 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1785 EXPECT_TRUE(result);
1786 }
1787
1788 {
1789 JSHandle<EcmaString> allString = factory->NewFromUtf8("你好");
1790 JSHandle<EcmaString> firstString = factory->NewFromUtf8("");
1791 JSHandle<EcmaString> secondString = factory->NewFromUtf8("你好");
1792 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1793 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1794 EXPECT_TRUE(result);
1795 }
1796
1797 {
1798 JSHandle<EcmaString> allString = factory->NewFromUtf8("233");
1799 JSHandle<EcmaString> firstString = factory->NewFromUtf8("233");
1800 JSHandle<EcmaString> secondString = factory->NewFromUtf8("");
1801 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1802 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1803 EXPECT_TRUE(result);
1804 }
1805
1806 {
1807 JSHandle<EcmaString> allString = factory->NewFromUtf8("233");
1808 JSHandle<EcmaString> firstString = factory->NewFromUtf8("");
1809 JSHandle<EcmaString> secondString = factory->NewFromUtf8("233");
1810 JSHandle<EcmaString> ans = factory->ConcatFromString(firstString, secondString);
1811 bool result = EcmaStringAccessor::StringsAreEqual(*allString, *ans);
1812 EXPECT_TRUE(result);
1813 }
1814 }
1815
1816 /*
1817 * @tc.name: CanBeCompressed
1818 * @tc.desc: Check whether the bool returned through calling CanBeCompressed function is within expectations.
1819 * @tc.type: FUNC
1820 * @tc.require:
1821 */
HWTEST_F_L0(EcmaStringAccessorTest,CanBeCompressed)1822 HWTEST_F_L0(EcmaStringAccessorTest, CanBeCompressed)
1823 {
1824 uint8_t arrayU8[] = {12, 34, 77, 127, 99, 1};
1825 uint16_t arrayU16Comp[] = {1, 4, 37, 91, 127, 1};
1826 uint16_t arrayU16NotComp[] = {72, 43, 337, 961, 1317, 65535};
1827 EXPECT_TRUE(EcmaStringAccessor::CanBeCompressed(arrayU8, sizeof(arrayU8) / sizeof(arrayU8[0])));
1828 EXPECT_TRUE(EcmaStringAccessor::CanBeCompressed(arrayU16Comp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0])));
1829 EXPECT_FALSE(EcmaStringAccessor::CanBeCompressed(arrayU16NotComp, sizeof(arrayU16Comp) / sizeof(arrayU16Comp[0])));
1830 }
1831
1832 /*
1833 * @tc.name: TryToLower
1834 * @tc.desc: Check whether the EcmaString created through calling TryToLower function is within expectations.
1835 * is within expectations.
1836 * @tc.type: FUNC
1837 * @tc.require:
1838 */
HWTEST_F_L0(EcmaStringAccessorTest,TryToLower)1839 HWTEST_F_L0(EcmaStringAccessorTest, TryToLower)
1840 {
1841 ObjectFactory* factory = instance->GetFactory();
1842 JSHandle<EcmaString> lowerStr = factory->NewFromASCII("aaabbbcccddd");
1843 JSHandle<EcmaString> upperStr = factory->NewFromASCII("AAABBBCCCDDD");
1844 JSHandle<EcmaString> testStr1 = factory->NewFromASCII("aaaBBBcccDDD");
1845 JSHandle<EcmaString> testStr2 = factory->NewFromASCII("AAAbbbcccDDD");
1846 std::vector<JSHandle<EcmaString>> caseStrings{upperStr, testStr1, testStr2};
1847 EcmaTestCommon::TryLowerCommonCase(thread, instance, lowerStr, caseStrings);
1848 }
1849 } // namespace panda::test
1850