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