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