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