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