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