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
20using namespace panda::ecmascript;
21
22namespace panda::test {
23class EcmaStringTest : public BaseTestWithScope<false> {
24public:
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 */
43HWTEST_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 */
59HWTEST_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 */
73HWTEST_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 */
103HWTEST_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 */
123HWTEST_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 */
150HWTEST_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 */
194HWTEST_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 */
222HWTEST_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 */
251HWTEST_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 */
289HWTEST_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 */
317HWTEST_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 */
355HWTEST_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 */
393HWTEST_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 */
423HWTEST_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 */
453HWTEST_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 */
483HWTEST_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 */
507HWTEST_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 */
531HWTEST_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 */
554HWTEST_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 */
598HWTEST_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 */
624HWTEST_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 */
643HWTEST_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 */
671HWTEST_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 */
697HWTEST_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 */
715HWTEST_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 */
740HWTEST_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 */
767HWTEST_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 */
786HWTEST_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 */
845HWTEST_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 */
888HWTEST_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 */
923HWTEST_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 */
956HWTEST_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 */
987HWTEST_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 */
1018HWTEST_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 */
1051HWTEST_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 */
1082HWTEST_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 */
1109HWTEST_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 */
1135HWTEST_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 */
1162HWTEST_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 */
1184HWTEST_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 */
1206HWTEST_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 */
1233HWTEST_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 */
1261HWTEST_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 */
1295HWTEST_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 */
1308HWTEST_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 */
1340HWTEST_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 */
1376HWTEST_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 */
1413HWTEST_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 */
1431HWTEST_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 */
1449HWTEST_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 */
1470HWTEST_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 */
1491HWTEST_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 */
1512HWTEST_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 */
1526HWTEST_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 */
1543HWTEST_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 */
1577HWTEST_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 */
1676HWTEST_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 */
1727HWTEST_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}  // namespace panda::test