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