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