1/*
2 * Copyright (c) 2023 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 ConstantStringTest : public BaseTestWithScope<false> {
24};
25
26/*
27 * @tc.name: CreateConstantString
28 * @tc.desc: Check whether the EcmaString created through calling CreateConstantString function is within expectations.
29 * @tc.type: FUNC
30 * @tc.require:
31 */
32HWTEST_F_L0(ConstantStringTest, CreateEmptyString)
33{
34    JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateConstantString(instance, nullptr,
35        0U, true));
36    EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrEmpty).IsConstantString());
37    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).GetLength(), 0U);
38    EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrEmpty).IsUtf8());
39    EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrEmpty).IsUtf16());
40}
41
42/*
43 * @tc.name: CreateConstantString
44 * @tc.desc: Check whether the EcmaString created through calling CreateConstantString function is within expectations.
45 * @tc.type: FUNC
46 * @tc.require:
47 */
48HWTEST_F_L0(ConstantStringTest, CreateConstantString)
49{
50    uint8_t arrayU8[] = {"xyz123!@#"};
51    size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
52    JSHandle<EcmaString> handleEcmaStrU8(thread,
53        EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
54    for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
55        EXPECT_EQ(arrayU8[i], EcmaStringAccessor(handleEcmaStrU8).Get(i));
56    }
57    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetLength(), lengthEcmaStrU8);
58    EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU8).IsUtf8());
59    EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU8).IsUtf16());
60}
61
62/*
63 * @tc.name: ObjectSize
64 * @tc.desc: Check whether the value returned through calling ObjectSize function is within expectations.
65 * @tc.type: FUNC
66 * @tc.require:
67 */
68HWTEST_F_L0(ConstantStringTest, ObjectSize)
69{
70    JSHandle<EcmaString> handleEcmaStrEmpty(thread, EcmaStringAccessor::CreateConstantString(instance, nullptr,
71        0U, true));
72    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrEmpty).ObjectSize(), ConstantString::SIZE);
73
74    uint8_t arrayU8[] = {"abcde"};
75    size_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
76    JSHandle<EcmaString> handleEcmaStrU8(thread,
77        EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
78    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).ObjectSize(), ConstantString::SIZE);
79    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetLength(), lengthEcmaStrU8);
80}
81
82/*
83 * @tc.name: Compare_001
84 * @tc.desc: Check whether the value returned through calling Compare function between EcmaStrings made by
85 * CreateFromUtf8() is within expectations.
86 * @tc.type: FUNC
87 * @tc.require:
88 */
89HWTEST_F_L0(ConstantStringTest, Compare_001)
90{
91    // Compare(). Between EcmaStrings made by CreateConstantString().
92    uint8_t arrayU8No1[3] = {1, 23};
93    uint8_t arrayU8No2[4] = {1, 23, 49};
94    uint8_t arrayU8No3[6] = {1, 23, 45, 97, 127};
95    uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
96    uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
97    uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
98    JSHandle<EcmaString> handleEcmaStrU8No1(thread,
99        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
100    JSHandle<EcmaString> handleEcmaStrU8No2(thread,
101        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
102    JSHandle<EcmaString> handleEcmaStrU8No3(thread,
103        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
104    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU8No2), -1);
105    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No1), 1);
106    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU8No3), 49 - 45);
107    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No3, handleEcmaStrU8No2), 45 - 49);
108}
109
110/*
111 * @tc.name: Compare_005
112 * @tc.desc: Check whether the value returned through calling Compare function between EcmaString made by
113 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
114 * @tc.type: FUNC
115 * @tc.require:
116 */
117HWTEST_F_L0(ConstantStringTest, Compare_005)
118{
119    // Compare(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false).
120    uint8_t arrayU8No1[3] = {1, 23};
121    uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
122    JSHandle<EcmaString> handleEcmaStrU8No1(thread,
123        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
124
125    uint8_t arrayU8No2[4] = {1, 23, 49};
126    uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
127    JSHandle<EcmaString> handleEcmaStrU8No2(thread,
128        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
129
130    uint16_t arrayU16NotCompNo1[] = {1, 23};
131    uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
132    JSHandle<EcmaString> handleEcmaStrU16NotCompNo1(thread,
133        EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1, true));
134
135    uint16_t arrayU16NotCompNo2[] = {1, 23, 49};
136    uint32_t lengthEcmaStrU16NotCompNo2 = sizeof(arrayU16NotCompNo2) / sizeof(arrayU16NotCompNo2[0]);
137    JSHandle<EcmaString> handleEcmaStrU16NotCompNo2(thread,
138        EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo2[0], lengthEcmaStrU16NotCompNo2, true));
139
140    uint16_t arrayU16NotCompNo3[] = {1, 23, 456, 6789, 65535, 127};
141    uint32_t lengthEcmaStrU16NotCompNo3 = sizeof(arrayU16NotCompNo3) / sizeof(arrayU16NotCompNo3[0]);
142    JSHandle<EcmaString> handleEcmaStrU16NotCompNo3(thread,
143        EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16NotCompNo3[0], lengthEcmaStrU16NotCompNo3, false));
144
145    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo1), 0);
146    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo1, handleEcmaStrU8No1), 0);
147    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No1, handleEcmaStrU16NotCompNo2), -1);
148    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo2, handleEcmaStrU8No1), 1);
149    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU8No2, handleEcmaStrU16NotCompNo3), 49 - 456);
150    EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStrU16NotCompNo3, handleEcmaStrU8No2), 456 - 49);
151}
152
153/*
154 * @tc.name: Concat_001
155 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
156 * CreateConstantString() and EcmaString made by CreateConstantString() is within expectations.
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160HWTEST_F_L0(ConstantStringTest, Concat_001)
161{
162    // Concat(). EcmaString made by CreateConstantString() and EcmaString made by CreateConstantString().
163    uint8_t arrayFrontU8[] = {"abcdef"};
164    uint8_t arrayBackU8[] = {"ABCDEF"};
165    uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1;
166    uint32_t lengthEcmaStrBackU8 = sizeof(arrayBackU8) - 1;
167    JSHandle<EcmaString> handleEcmaStrFrontU8(thread,
168        EcmaStringAccessor::CreateConstantString(instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true));
169    JSHandle<EcmaString> handleEcmaStrBackU8(thread,
170        EcmaStringAccessor::CreateConstantString(instance, &arrayBackU8[0], lengthEcmaStrBackU8, true));
171    JSHandle<EcmaString> handleEcmaStrConcatU8(thread,
172        EcmaStringAccessor::Concat(instance, handleEcmaStrFrontU8, handleEcmaStrBackU8));
173    EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrConcatU8).IsUtf8());
174    for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) {
175        EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).Get(i), arrayFrontU8[i]);
176    }
177    for (uint32_t i = 0; i < lengthEcmaStrBackU8; i++) {
178        EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).Get(i + lengthEcmaStrFrontU8), arrayBackU8[i]);
179    }
180    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8).GetLength(), lengthEcmaStrFrontU8 + lengthEcmaStrBackU8);
181}
182
183/*
184 * @tc.name: Concat_003
185 * @tc.desc: Check whether the EcmaString returned through calling Concat function between EcmaString made by
186 * CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false) is within expectations.
187 * @tc.type: FUNC
188 * @tc.require:
189 */
190HWTEST_F_L0(ConstantStringTest, Concat_003)
191{
192    // Concat(). EcmaString made by CreateFromUtf8() and EcmaString made by CreateFromUtf16( , , , false).
193    uint8_t arrayFrontU8[] = {"abcdef"};
194    uint16_t arrayBackU16NotComp[] = {88, 768, 1, 270, 345, 333};
195    uint32_t lengthEcmaStrFrontU8 = sizeof(arrayFrontU8) - 1;
196    uint32_t lengthEcmaStrBackU16NotComp = sizeof(arrayBackU16NotComp) / sizeof(arrayBackU16NotComp[0]);
197    JSHandle<EcmaString> handleEcmaStrFrontU8(thread,
198        EcmaStringAccessor::CreateConstantString(instance, &arrayFrontU8[0], lengthEcmaStrFrontU8, true));
199    JSHandle<EcmaString> handleEcmaStrBackU16NotComp(thread,
200        EcmaStringAccessor::CreateFromUtf16(instance, &arrayBackU16NotComp[0], lengthEcmaStrBackU16NotComp, false));
201    JSHandle<EcmaString> handleEcmaStrConcatU8U16NotComp(thread,
202        EcmaStringAccessor::Concat(instance, handleEcmaStrFrontU8, handleEcmaStrBackU16NotComp));
203    EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).IsUtf16());
204    for (uint32_t i = 0; i < lengthEcmaStrFrontU8; i++) {
205        EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).Get(i), arrayFrontU8[i]);
206    }
207    for (uint32_t i = 0; i < lengthEcmaStrBackU16NotComp; i++) {
208        EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).Get(i + lengthEcmaStrFrontU8),
209            arrayBackU16NotComp[i]);
210    }
211    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrConcatU8U16NotComp).GetLength(),
212        lengthEcmaStrFrontU8 + lengthEcmaStrBackU16NotComp);
213}
214
215/*
216 * @tc.name: FastSubString_001
217 * @tc.desc: Check whether the EcmaString returned through calling FastSubString function from EcmaString made by
218 * CreateConstantString() is within expectations.
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222HWTEST_F_L0(ConstantStringTest, FastSubString_001)
223{
224    // FastSubString(). From EcmaString made by CreateConstantString().
225    std::vector<uint8_t> arrayU8{3, 7, 19, 54, 99};
226    auto func = std::bind(EcmaStringAccessor::CreateConstantString, std::placeholders::_1, std::placeholders::_2,
227        std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, 0);
228    EcmaTestCommon::FastSubStringCommonCase(thread, instance, arrayU8, func);
229}
230
231/*
232 * @tc.name: GetUtf8Length
233 * @tc.desc: Check whether the value returned through calling GetUtf8Length function is within expectations.
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237HWTEST_F_L0(ConstantStringTest, GetUtf8Length)
238{
239    uint8_t arrayU8[6] = {3, 7, 19, 54, 99};
240    uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
241    JSHandle<EcmaString> handleEcmaStrU8(thread,
242    EcmaStringAccessor::CreateFromUtf8(instance, &arrayU8[0], lengthEcmaStrU8, true));
243    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetUtf8Length(), lengthEcmaStrU8 + 1);
244}
245
246/*
247 * @tc.name: GetDataUtf8
248 * @tc.desc: Check whether the pointer returned through calling GetDataUtf8 function is within expectations.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252HWTEST_F_L0(ConstantStringTest, GetDataUtf8)
253{
254    // From EcmaString made by CreateFromUtf8().
255    uint8_t arrayU8[] = {"abcde"};
256    uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
257    JSHandle<EcmaString> handleEcmaStrU8(thread,
258        EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
259    for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
260        EXPECT_EQ(*(EcmaStringAccessor(handleEcmaStrU8).GetDataUtf8() + i), arrayU8[i]);
261    }
262}
263
264/*
265 * @tc.name: IndexOf_001
266 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateConstantString() calling
267 * IndexOf function with a target EcmaString made by CreateConstantString() is within expectations.
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271HWTEST_F_L0(ConstantStringTest, IndexOf_001)
272{
273    // IndexOf(). Find EcmaString made by CreateConstantString() From EcmaString made by CreateConstantString().
274    uint8_t arrayU8From[7] = {23, 25, 1, 3, 39, 80};
275    uint8_t arrayU8Target[4] = {1, 3, 39};
276    uint32_t lengthEcmaStrU8From = sizeof(arrayU8From) - 1;
277    uint32_t lengthEcmaStrU8Target = sizeof(arrayU8Target) - 1;
278    JSHandle<EcmaString> handleEcmaStr(thread,
279        EcmaStringAccessor::CreateConstantString(instance, &arrayU8From[0], lengthEcmaStrU8From, true));
280    JSHandle<EcmaString> handleEcmaStr1(thread,
281        EcmaStringAccessor::CreateConstantString(instance, &arrayU8Target[0], lengthEcmaStrU8Target, true));
282    int32_t posStart = 0;
283    EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
284    EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr1, handleEcmaStr, posStart), -1);
285    posStart = -1;
286    EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
287    posStart = 1;
288    EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
289    posStart = 2;
290    EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), 2);
291    posStart = 3;
292    EXPECT_EQ(EcmaStringAccessor::IndexOf(instance, handleEcmaStr, handleEcmaStr1, posStart), -1);
293}
294
295/*
296 * @tc.name: IndexOf_004
297 * @tc.desc: Check whether the value returned through a source EcmaString made by CreateConstantString() calling
298 * IndexOf function with a target EcmaString made by CreateFromUtf16() is within expectations.
299 * @tc.type: FUNC
300 * @tc.require:
301 */
302HWTEST_F_L0(ConstantStringTest, IndexOf_004)
303{
304    // IndexOf(). Find EcmaString made by CreateFromUtf16() From EcmaString made by CreateConstantString().
305    std::vector<uint16_t> ecmaStrU16NotCompTarget = {3, 39, 80};
306    std::vector<uint8_t> arrayU8From{23, 25, 1, 3, 39, 80};
307    auto func = std::bind(EcmaStringAccessor::CreateConstantString, std::placeholders::_1, std::placeholders::_2,
308        std::placeholders::_3, std::placeholders::_4, MemSpaceType::SHARED_OLD_SPACE, 0);
309    EcmaTestCommon::IndexOfCommonCase(thread, instance, ecmaStrU16NotCompTarget, arrayU8From, func);
310}
311
312/*
313 * @tc.name: StringsAreEqual_001
314 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with two EcmaStrings made by
315 * CreateConstantString() is within expectations.
316 * @tc.type: FUNC
317 * @tc.require:
318 */
319HWTEST_F_L0(ConstantStringTest, StringsAreEqual_001)
320{
321    // StringsAreEqual().
322    uint8_t arrayU8No1[4] = {45, 92, 78};
323    uint8_t arrayU8No2[4] = {45, 92, 78};
324    uint8_t arrayU8No3[5] = {45, 92, 78, 1};
325    uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
326    uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
327    uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
328    JSHandle<EcmaString> handleEcmaStrU8No1(thread,
329        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
330    JSHandle<EcmaString> handleEcmaStrU8No2(thread,
331        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
332    JSHandle<EcmaString> handleEcmaStrU8No3(thread,
333        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
334    EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU8No2));
335    EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU8No3));
336    EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No3, *handleEcmaStrU8No1));
337}
338
339/*
340 * @tc.name: StringsAreEqual_002
341 * @tc.desc: Check whether the bool returned through calling StringsAreEqual function with a EcmaString made by
342 * CreateConstantString() and a EcmaString made by CreateFromUtf16(, , , true) is within expectations.
343 * @tc.type: FUNC
344 * @tc.require:
345 */
346HWTEST_F_L0(ConstantStringTest, StringsAreEqual_002)
347{
348    // StringsAreEqual().
349    uint8_t arrayU8No1[4] = {45, 92, 78};
350    uint16_t arrayU16CompNo2[] = {45, 92, 78};
351    uint16_t arrayU16CompNo3[] = {45, 92, 78, 1};
352    uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
353    uint32_t lengthEcmaStrU16CompNo2 = sizeof(arrayU16CompNo2) / sizeof(arrayU16CompNo2[0]);
354    uint32_t lengthEcmaStrU16CompNo3 = sizeof(arrayU16CompNo3) / sizeof(arrayU16CompNo3[0]);
355    JSHandle<EcmaString> handleEcmaStrU8No1(thread,
356        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
357    JSHandle<EcmaString> handleEcmaStrU16CompNo2(thread,
358        EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo2[0], lengthEcmaStrU16CompNo2, true));
359    JSHandle<EcmaString> handleEcmaStrU16CompNo3(thread,
360        EcmaStringAccessor::CreateFromUtf16(instance, &arrayU16CompNo3[0], lengthEcmaStrU16CompNo3, true));
361    EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16CompNo2));
362    EXPECT_FALSE(EcmaStringAccessor::StringsAreEqual(*handleEcmaStrU8No1, *handleEcmaStrU16CompNo3));
363}
364
365/*
366 * @tc.name: StringsAreEqualUtf8_001
367 * @tc.desc: Check whether the bool returned through calling StringIsEqualUint8Data function with an EcmaString made by
368 * CreateConstantString() and an Array(uint8_t) is within expectations.
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372HWTEST_F_L0(ConstantStringTest, StringsAreEqualUtf8_001)
373{
374    // StringIsEqualUint8Data(). EcmaString made by CreateConstantString(), Array:U8.
375    uint8_t arrayU8No1[4] = {45, 92, 78};
376    uint8_t arrayU8No2[5] = {45, 92, 78, 24};
377    uint8_t arrayU8No3[3] = {45, 92};
378    uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
379    uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
380    uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
381    JSHandle<EcmaString> handleEcmaStrU8No1(thread,
382        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
383    JSHandle<EcmaString> handleEcmaStrU8No2(thread,
384        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
385    JSHandle<EcmaString> handleEcmaStrU8No3(thread,
386        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
387    EXPECT_TRUE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No1, &arrayU8No1[0], lengthEcmaStrU8No1,
388        true));
389    EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No1, &arrayU8No1[0], lengthEcmaStrU8No1,
390        false));
391    EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No2, &arrayU8No1[0], lengthEcmaStrU8No1,
392        true));
393    EXPECT_FALSE(EcmaStringAccessor::StringIsEqualUint8Data(*handleEcmaStrU8No3, &arrayU8No1[0], lengthEcmaStrU8No1,
394        true));
395}
396
397/*
398 * @tc.name: StringsAreEqualUtf16_001
399 * @tc.desc: Check whether the bool returned through calling StringsAreEqualUtf16 function with an EcmaString made by
400 * CreateConstantString() and an Array(uint16_t) is within expectations.
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404HWTEST_F_L0(ConstantStringTest, StringsAreEqualUtf16_001)
405{
406    // StringsAreEqualUtf16(). EcmaString made by CreateConstantString, Array:U16(1-127).
407    uint8_t arrayU8No3[3] = {45, 92};
408    uint8_t arrayU8No1[4] = {45, 92, 78};
409    uint8_t arrayU8No2[5] = {45, 92, 78, 24};
410    uint16_t arrayU16NotCompNo1[] = {45, 92, 78};
411    uint32_t lengthEcmaStrU8No1 = sizeof(arrayU8No1) - 1;
412    uint32_t lengthEcmaStrU8No2 = sizeof(arrayU8No2) - 1;
413    uint32_t lengthEcmaStrU8No3 = sizeof(arrayU8No3) - 1;
414    uint32_t lengthEcmaStrU16NotCompNo1 = sizeof(arrayU16NotCompNo1) / sizeof(arrayU16NotCompNo1[0]);
415    JSHandle<EcmaString> handleEcmaStrU8No1(thread,
416        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No1[0], lengthEcmaStrU8No1, true));
417    JSHandle<EcmaString> handleEcmaStrU8No2(thread,
418        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No2[0], lengthEcmaStrU8No2, true));
419    JSHandle<EcmaString> handleEcmaStrU8No3(thread,
420        EcmaStringAccessor::CreateConstantString(instance, &arrayU8No3[0], lengthEcmaStrU8No3, true));
421    EXPECT_TRUE(
422        EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU8No1,
423            &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
424    EXPECT_FALSE(
425        EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU8No2,
426            &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
427    EXPECT_FALSE(
428        EcmaStringAccessor::StringsAreEqualUtf16(*handleEcmaStrU8No3,
429            &arrayU16NotCompNo1[0], lengthEcmaStrU16NotCompNo1));
430}
431
432/*
433 * @tc.name: GetHashcode_001
434 * @tc.desc: Check whether the value returned through an EcmaString made by CreateConstantString() calling
435 * GetHashcode function is within expectations.
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439HWTEST_F_L0(ConstantStringTest, GetHashcode_001)
440{
441    // GetHashcode(). EcmaString made by CreateConstantString().
442    uint8_t arrayU8[] = {"abc"};
443    uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
444    JSHandle<EcmaString> handleEcmaStrU8(thread,
445        EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
446    uint32_t hashExpect = 0;
447    for (uint32_t i = 0; i < lengthEcmaStrU8; i++) {
448        hashExpect = hashExpect * 31 + arrayU8[i];
449    }
450    EXPECT_EQ(EcmaStringAccessor(handleEcmaStrU8).GetHashcode(), hashExpect);
451}
452
453/*
454 * @tc.name: SetIsInternString
455 * @tc.desc: Call SetIsInternString function, check whether the bool returned through calling IsInternString function
456 * is within expectations.
457 * @tc.type: FUNC
458 * @tc.require:
459 */
460HWTEST_F_L0(ConstantStringTest, SetIsInternString)
461{
462    uint8_t arrayU8[] = {"abc"};
463    uint32_t lengthEcmaStrU8 = sizeof(arrayU8) - 1;
464    JSHandle<EcmaString> handleEcmaStrU8(thread,
465        EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], lengthEcmaStrU8, true));
466    EXPECT_FALSE(EcmaStringAccessor(handleEcmaStrU8).IsInternString());
467    EcmaStringAccessor(handleEcmaStrU8).SetInternString();
468    EXPECT_TRUE(EcmaStringAccessor(handleEcmaStrU8).IsInternString());
469}
470
471/*
472 * @tc.name: EqualToSplicedString
473 * @tc.desc: Tests whether the source string is equal to the concatenated string.
474 * is within expectations.
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478HWTEST_F_L0(ConstantStringTest, EqualToSplicedString)
479{
480    uint8_t arrayU8[] = {"Startnow"};
481    uint32_t srcLengthEcmaStrU8 = sizeof(arrayU8) - 1;
482    JSHandle<EcmaString> sourceString(thread,
483    EcmaStringAccessor::CreateConstantString(instance, &arrayU8[0], srcLengthEcmaStrU8, true));
484    uint8_t firstArrayU8[] = {"Start"};
485    uint32_t firstLengthEcmaStrU8 = sizeof(firstArrayU8) - 1;
486    JSHandle<EcmaString> firstString(thread,
487    EcmaStringAccessor::CreateConstantString(instance, &firstArrayU8[0], firstLengthEcmaStrU8, true));
488    uint8_t secondArrayU8[] = {"now"};
489    uint32_t secondLengthEcmaStrU8 = sizeof(secondArrayU8) - 1;
490    JSHandle<EcmaString> secondString(thread,
491    EcmaStringAccessor::CreateConstantString(instance, &secondArrayU8[0], secondLengthEcmaStrU8, true));
492
493    EXPECT_TRUE(EcmaStringAccessor(sourceString).IsUtf8());
494    EXPECT_TRUE(EcmaStringAccessor(firstString).IsUtf8());
495    EXPECT_TRUE(EcmaStringAccessor(secondString).IsUtf8());
496    bool result =  EcmaStringAccessor(sourceString).EqualToSplicedString(*firstString, *secondString);
497    EXPECT_TRUE(result);
498}
499
500/*
501 * @tc.name: TryToLower
502 * @tc.desc: Check whether the EcmaString created through calling TryToLower function is within expectations.
503 * is within expectations.
504 * @tc.type: FUNC
505 * @tc.require:
506 */
507HWTEST_F_L0(ConstantStringTest, ConvertUtf8ToLowerOrUpper)
508{
509    uint8_t lowerU8[] = {"aaabbbcccddd"};
510    uint32_t lowerLength = sizeof(lowerU8) - 1;
511    JSHandle<EcmaString> lowerStr(thread,
512        EcmaStringAccessor::CreateConstantString(instance, &lowerU8[0], lowerLength, true));
513    uint8_t upperU8[] = {"AAABBBCCCDDD"};
514    uint32_t upperLength = sizeof(upperU8) - 1;
515    JSHandle<EcmaString> upperStr(thread,
516        EcmaStringAccessor::CreateConstantString(instance, &upperU8[0], upperLength, true));
517
518    uint8_t testStr1U8[] = {"aaaBBBcccDDD"};
519    uint32_t testLength1 = sizeof(testStr1U8) - 1;
520    JSHandle<EcmaString> testStr1(thread,
521        EcmaStringAccessor::CreateConstantString(instance, &testStr1U8[0], testLength1, true));
522
523    uint8_t testStr2U8[] = {"AAAbbbcccDDD"};
524    uint32_t testLength2 = sizeof(testStr2U8) - 1;
525    JSHandle<EcmaString> testStr2(thread,
526        EcmaStringAccessor::CreateConstantString(instance, &testStr2U8[0], testLength2, true));
527    std::vector<JSHandle<EcmaString>> caseStrings{upperStr, testStr1, testStr2};
528    EcmaTestCommon::TryLowerCommonCase(thread, instance, lowerStr, caseStrings);
529}
530}  // namespace panda::test