1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/builtins/builtins_string.h"
17
18 #include "ecmascript/base/builtins_base.h"
19 #include "ecmascript/builtins/builtins_regexp.h"
20 #include "ecmascript/ecma_runtime_call_info.h"
21 #include "ecmascript/ecma_string.h"
22 #include "ecmascript/ecma_vm.h"
23 #include "ecmascript/global_env.h"
24 #include "ecmascript/js_array.h"
25 #include "ecmascript/js_primitive_ref.h"
26 #include "ecmascript/js_regexp.h"
27 #include "ecmascript/js_tagged_value.h"
28 #include "ecmascript/object_factory.h"
29 #include "ecmascript/tests/test_helper.h"
30
31 using namespace panda::ecmascript;
32 using namespace panda::ecmascript::builtins;
33
34 namespace panda::test {
35 class BuiltinsStringTest : public testing::Test {
36 public:
SetUpTestCase()37 static void SetUpTestCase()
38 {
39 GTEST_LOG_(INFO) << "SetUpTestCase";
40 }
41
TearDownTestCase()42 static void TearDownTestCase()
43 {
44 GTEST_LOG_(INFO) << "TearDownCase";
45 }
46
SetUp()47 void SetUp() override
48 {
49 JSRuntimeOptions options;
50 #if PANDA_TARGET_LINUX
51 // for consistency requirement, use ohos_icu4j/data as icu-data-path
52 options.SetIcuDataPath(ICU_PATH);
53 #endif
54 options.SetEnableForceGC(true);
55 instance = JSNApi::CreateEcmaVM(options);
56 instance->SetEnableForceGC(true);
57 ASSERT_TRUE(instance != nullptr) << "Cannot create EcmaVM";
58 thread = instance->GetJSThread();
59 scope = new EcmaHandleScope(thread);
60 }
61
TearDown()62 void TearDown() override
63 {
64 TestHelper::DestroyEcmaVMWithScope(instance, scope);
65 }
66
67 EcmaVM *instance {nullptr};
68 EcmaHandleScope *scope {nullptr};
69 JSThread *thread {nullptr};
70 };
71
CreateBuiltinsStringRegExpObjByPatternAndFlags(JSThread * thread,const JSHandle<EcmaString> & pattern,const JSHandle<EcmaString> & flags)72 JSTaggedValue CreateBuiltinsStringRegExpObjByPatternAndFlags(JSThread *thread, const JSHandle<EcmaString> &pattern,
73 const JSHandle<EcmaString> &flags)
74 {
75 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
76 JSHandle<JSFunction> regexp(env->GetRegExpFunction());
77 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
78
79 // 8 : test case
80 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, regexp.GetTaggedValue(), 8);
81 ecmaRuntimeCallInfo->SetFunction(regexp.GetTaggedValue());
82 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
83 ecmaRuntimeCallInfo->SetCallArg(0, pattern.GetTaggedValue());
84 ecmaRuntimeCallInfo->SetCallArg(1, flags.GetTaggedValue());
85
86 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
87 JSTaggedValue result = BuiltinsRegExp::RegExpConstructor(ecmaRuntimeCallInfo);
88 TestHelper::TearDownFrame(thread, prev);
89 return result;
90 }
91
HWTEST_F_L0(BuiltinsStringTest,StringConstructor1)92 HWTEST_F_L0(BuiltinsStringTest, StringConstructor1)
93 {
94 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
95
96 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
97 JSHandle<JSFunction> string(env->GetStringFunction());
98 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
99 JSHandle<EcmaString> string2 = factory->NewFromASCII("ABC");
100
101 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, string.GetTaggedValue(), 6);
102 ecmaRuntimeCallInfo->SetFunction(string.GetTaggedValue());
103 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
104 ecmaRuntimeCallInfo->SetCallArg(0, string2.GetTaggedValue());
105
106 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
107 JSTaggedValue result = BuiltinsString::StringConstructor(ecmaRuntimeCallInfo);
108 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
109 ASSERT_TRUE(value.IsECMAObject());
110 JSHandle<JSPrimitiveRef> ref(thread, JSPrimitiveRef::Cast(value.GetTaggedObject()));
111 JSHandle<EcmaString> test = factory->NewFromASCII("ABC");
112 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
113 JSHandle<EcmaString>(thread, EcmaString::Cast(ref->GetValue())), test), 0);
114 }
115
116 // String.fromCharCode(65, 66, 67)
HWTEST_F_L0(BuiltinsStringTest,fromCharCode1)117 HWTEST_F_L0(BuiltinsStringTest, fromCharCode1)
118 {
119 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
120 const double arg1 = 65;
121 const double arg2 = 66;
122 const double arg3 = 67;
123
124 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
125 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
126 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
127 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(arg1));
128 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(arg2));
129 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(arg3));
130
131 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
132 JSTaggedValue result = BuiltinsString::FromCharCode(ecmaRuntimeCallInfo);
133 ASSERT_TRUE(result.IsString());
134 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
135 JSHandle<JSTaggedValue> valueHandle(thread, JSTaggedValue(value.GetTaggedObject()));
136 JSHandle<EcmaString> test = factory->NewFromASCII("ABC");
137 ASSERT_EQ(EcmaStringAccessor::Compare(instance, JSHandle<EcmaString>::Cast(valueHandle), test), 0);
138 }
139
140 // String.fromCodePoint(65, 66, 67)
HWTEST_F_L0(BuiltinsStringTest,fromCodePoint1)141 HWTEST_F_L0(BuiltinsStringTest, fromCodePoint1)
142 {
143 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
144 const double arg1 = 65;
145 const double arg2 = 66;
146 const double arg3 = 67;
147
148 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
149 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
150 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
151 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(arg1));
152 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(arg2));
153 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(arg3));
154
155 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
156 JSTaggedValue result = BuiltinsString::FromCodePoint(ecmaRuntimeCallInfo);
157 ASSERT_TRUE(result.IsString());
158 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
159 JSHandle<EcmaString> test = factory->NewFromASCII("ABC");
160 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
161 }
162
163 // "abcabcabc".charAt(5)
HWTEST_F_L0(BuiltinsStringTest,charAt1)164 HWTEST_F_L0(BuiltinsStringTest, charAt1)
165 {
166 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
167 JSHandle<EcmaString> thisVal = factory->NewFromASCII("abcabcabc");
168
169 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
170 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
171 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
172 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(5)));
173
174 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
175 JSTaggedValue result = BuiltinsString::CharAt(ecmaRuntimeCallInfo);
176 ASSERT_TRUE(result.IsString());
177 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
178 JSHandle<EcmaString> test = factory->NewFromASCII("c");
179 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
180 }
181
182 // "一二三四".charAt(2)
HWTEST_F_L0(BuiltinsStringTest,charAt2)183 HWTEST_F_L0(BuiltinsStringTest, charAt2)
184 {
185 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
186 JSHandle<EcmaString> thisVal = factory->NewFromUtf8("一二三四");
187
188 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
189 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
190 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
191 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2)));
192
193 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
194 JSTaggedValue result = BuiltinsString::CharAt(ecmaRuntimeCallInfo);
195 ASSERT_TRUE(result.IsString());
196 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
197 JSHandle<EcmaString> test = factory->NewFromUtf8("三");
198 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
199 }
200
201 // "abcabcabc".charAt(-1)
HWTEST_F_L0(BuiltinsStringTest,charAt3)202 HWTEST_F_L0(BuiltinsStringTest, charAt3)
203 {
204 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
205 JSHandle<EcmaString> thisVal = factory->NewFromASCII("abcabcabc");
206
207 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
208 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
209 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
210 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-1)));
211
212 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
213 JSTaggedValue result = BuiltinsString::CharAt(ecmaRuntimeCallInfo);
214 ASSERT_TRUE(result.IsString());
215 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
216 JSHandle<EcmaString> test = factory->GetEmptyString();
217 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
218 }
219
220 // "ABC".charCodeAt(0)
HWTEST_F_L0(BuiltinsStringTest,charCodeAt1)221 HWTEST_F_L0(BuiltinsStringTest, charCodeAt1)
222 {
223 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
224 JSHandle<EcmaString> thisVal = factory->NewFromASCII("ABC");
225
226 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
227 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
228 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
229 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(0)));
230
231 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
232 JSTaggedValue result = BuiltinsString::CharCodeAt(ecmaRuntimeCallInfo);
233
234 ASSERT_EQ(result.GetRawData(), JSTaggedValue(65).GetRawData());
235 }
236
237 // "ABC".charCodeAt(-1)
HWTEST_F_L0(BuiltinsStringTest,charCodeAt2)238 HWTEST_F_L0(BuiltinsStringTest, charCodeAt2)
239 {
240 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
241 JSHandle<EcmaString> thisVal = factory->NewFromASCII("ABC");
242
243 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
244 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
245 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
246 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-1)));
247
248 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
249 JSTaggedValue result = BuiltinsString::CharCodeAt(ecmaRuntimeCallInfo);
250
251 JSTaggedValue test = BuiltinsString::GetTaggedDouble(base::NAN_VALUE);
252 ASSERT_EQ(result.GetRawData(), test.GetRawData());
253 }
254
255 // "ABC".codePointAt(1)
HWTEST_F_L0(BuiltinsStringTest,codePointAt1)256 HWTEST_F_L0(BuiltinsStringTest, codePointAt1)
257 {
258 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
259 JSHandle<EcmaString> thisVal = factory->NewFromASCII("ABC");
260
261 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
262 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
263 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
264 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(1)));
265
266 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
267 JSTaggedValue result = BuiltinsString::CodePointAt(ecmaRuntimeCallInfo);
268
269 ASSERT_EQ(result.GetRawData(), JSTaggedValue(66).GetRawData());
270 }
271
272 // 'a'.concat('b', 'c', 'd')
HWTEST_F_L0(BuiltinsStringTest,concat1)273 HWTEST_F_L0(BuiltinsStringTest, concat1)
274 {
275 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
276 JSHandle<EcmaString> thisStr = factory->NewFromASCII("a");
277 JSHandle<EcmaString> val1 = factory->NewFromASCII("b");
278 JSHandle<EcmaString> val2 = factory->NewFromASCII("c");
279 JSHandle<EcmaString> val3 = factory->NewFromASCII("d");
280
281 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
282 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
283 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
284 ecmaRuntimeCallInfo->SetCallArg(0, val1.GetTaggedValue());
285 ecmaRuntimeCallInfo->SetCallArg(1, val2.GetTaggedValue());
286 ecmaRuntimeCallInfo->SetCallArg(2, val3.GetTaggedValue());
287
288 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
289 JSTaggedValue result = BuiltinsString::Concat(ecmaRuntimeCallInfo);
290 ASSERT_TRUE(result.IsString());
291 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
292 JSHandle<EcmaString> test = factory->NewFromASCII("abcd");
293 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
294 }
295
296 // "abcabcabc".indexof('b')
HWTEST_F_L0(BuiltinsStringTest,indexof1)297 HWTEST_F_L0(BuiltinsStringTest, indexof1)
298 {
299 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
300 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
301 JSHandle<EcmaString> val = factory->NewFromASCII("b");
302
303 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
304 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
305 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
306 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
307
308 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
309 JSTaggedValue result = BuiltinsString::IndexOf(ecmaRuntimeCallInfo);
310
311 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
312 }
313
314 // "abcabcabc".indexof('b', 2)
HWTEST_F_L0(BuiltinsStringTest,indexof2)315 HWTEST_F_L0(BuiltinsStringTest, indexof2)
316 {
317 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
318 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
319 JSHandle<EcmaString> val = factory->NewFromASCII("b");
320
321 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
322 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
323 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
324 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
325 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(2)));
326
327 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
328 JSTaggedValue result = BuiltinsString::IndexOf(ecmaRuntimeCallInfo);
329
330 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
331 }
332
333 // "abcabcabc".indexof('d')
HWTEST_F_L0(BuiltinsStringTest,indexof3)334 HWTEST_F_L0(BuiltinsStringTest, indexof3)
335 {
336 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
337 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
338 JSHandle<EcmaString> val = factory->NewFromASCII("d");
339
340 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
341 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
342 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
343 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
344
345 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
346 JSTaggedValue result = BuiltinsString::IndexOf(ecmaRuntimeCallInfo);
347
348 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
349 }
350
351 // "abcabcabc".lastIndexOf('b')
HWTEST_F_L0(BuiltinsStringTest,lastIndexOf1)352 HWTEST_F_L0(BuiltinsStringTest, lastIndexOf1)
353 {
354 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
355 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
356 JSHandle<EcmaString> val = factory->NewFromASCII("b");
357
358 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
359 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
360 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
361 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
362
363 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
364 JSTaggedValue result = BuiltinsString::LastIndexOf(ecmaRuntimeCallInfo);
365
366 ASSERT_EQ(result.GetRawData(), JSTaggedValue(7).GetRawData());
367 }
368 // "abcabcabc".lastIndexOf('b', 2)
HWTEST_F_L0(BuiltinsStringTest,lastIndexOf2)369 HWTEST_F_L0(BuiltinsStringTest, lastIndexOf2)
370 {
371 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
372 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
373 JSHandle<EcmaString> val = factory->NewFromASCII("b");
374
375 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
376 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
377 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
378 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
379 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(2)));
380
381 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
382 JSTaggedValue result = BuiltinsString::LastIndexOf(ecmaRuntimeCallInfo);
383
384 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
385 }
386
387 // "abcabcabc".lastIndexOf('d')
HWTEST_F_L0(BuiltinsStringTest,lastIndexOf3)388 HWTEST_F_L0(BuiltinsStringTest, lastIndexOf3)
389 {
390 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
391 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
392 JSHandle<EcmaString> val = factory->NewFromASCII("d");
393
394 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
395 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
396 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
397 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
398
399 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
400 JSTaggedValue result = BuiltinsString::LastIndexOf(ecmaRuntimeCallInfo);
401
402 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
403 }
404
405 // "abcabcabc".includes('b')
HWTEST_F_L0(BuiltinsStringTest,Includes2)406 HWTEST_F_L0(BuiltinsStringTest, Includes2)
407 {
408 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
409 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
410 JSHandle<EcmaString> val = factory->NewFromASCII("b");
411
412 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
413 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
414 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
415 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
416
417 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
418 JSTaggedValue result = BuiltinsString::Includes(ecmaRuntimeCallInfo);
419
420 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
421 }
422
423 // "abccccccc".includes('b'，2)
HWTEST_F_L0(BuiltinsStringTest,Includes3)424 HWTEST_F_L0(BuiltinsStringTest, Includes3)
425 {
426 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
427 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abccccccc");
428 JSHandle<EcmaString> val = factory->NewFromASCII("b");
429
430 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
431 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
432 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
433 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
434 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(2)));
435
436 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
437 JSTaggedValue result = BuiltinsString::Includes(ecmaRuntimeCallInfo);
438
439 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
440 }
441
442 // "一二三四".includes('二')
HWTEST_F_L0(BuiltinsStringTest,Includes4)443 HWTEST_F_L0(BuiltinsStringTest, Includes4)
444 {
445 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
446 JSHandle<EcmaString> thisStr = factory->NewFromUtf8("一二三四");
447 JSHandle<EcmaString> val = factory->NewFromUtf8("二");
448
449 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
450 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
451 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
452 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
453
454 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
455 JSTaggedValue result = BuiltinsString::Includes(ecmaRuntimeCallInfo);
456
457 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
458 }
459
460 // "To be, or not to be, that is the question.".startsWith('To be')
HWTEST_F_L0(BuiltinsStringTest,startsWith1)461 HWTEST_F_L0(BuiltinsStringTest, startsWith1)
462 {
463 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
464 JSHandle<EcmaString> thisStr = factory->NewFromASCII("To be, or not to be, that is the question.");
465 JSHandle<EcmaString> val = factory->NewFromASCII("To be");
466
467 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
468 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
469 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
470 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
471
472 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
473 JSTaggedValue result = BuiltinsString::StartsWith(ecmaRuntimeCallInfo);
474
475 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
476 }
477
478 // "To be, or not to be, that is the question.".startsWith('not to be')
HWTEST_F_L0(BuiltinsStringTest,startsWith2)479 HWTEST_F_L0(BuiltinsStringTest, startsWith2)
480 {
481 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
482 JSHandle<EcmaString> thisStr = factory->NewFromASCII("To be, or not to be, that is the question.");
483 JSHandle<EcmaString> val = factory->NewFromASCII("not to be");
484
485 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
486 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
487 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
488 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
489
490 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
491 JSTaggedValue result = BuiltinsString::StartsWith(ecmaRuntimeCallInfo);
492
493 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
494 }
495
496 // "To be, or not to be, that is the question.".startsWith('not to be', 10)
HWTEST_F_L0(BuiltinsStringTest,startsWith3)497 HWTEST_F_L0(BuiltinsStringTest, startsWith3)
498 {
499 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
500 JSHandle<EcmaString> thisStr = factory->NewFromASCII("To be, or not to be, that is the question.");
501 JSHandle<EcmaString> val = factory->NewFromASCII("not to be");
502
503 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
504 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
505 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
506 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
507 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
508
509 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
510 JSTaggedValue result = BuiltinsString::StartsWith(ecmaRuntimeCallInfo);
511
512 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
513 }
514
515 // "To be, or not to be, that is the question.".endsWith('question.')
HWTEST_F_L0(BuiltinsStringTest,endsWith1)516 HWTEST_F_L0(BuiltinsStringTest, endsWith1)
517 {
518 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
519 JSHandle<EcmaString> thisStr = factory->NewFromASCII("To be, or not to be, that is the question.");
520 JSHandle<EcmaString> val = factory->NewFromASCII("question.");
521
522 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
523 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
524 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
525 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
526
527 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
528 JSTaggedValue result = BuiltinsString::EndsWith(ecmaRuntimeCallInfo);
529
530 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
531 }
532
533 // "To be, or not to be, that is the question.".endsWith('to be')
HWTEST_F_L0(BuiltinsStringTest,endsWith2)534 HWTEST_F_L0(BuiltinsStringTest, endsWith2)
535 {
536 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
537 JSHandle<EcmaString> thisStr = factory->NewFromASCII("To be, or not to be, that is the question.");
538 JSHandle<EcmaString> val = factory->NewFromASCII("to be");
539
540 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
541 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
542 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
543 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
544
545 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
546 JSTaggedValue result = BuiltinsString::EndsWith(ecmaRuntimeCallInfo);
547
548 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
549 }
550
551 // "To be, or not to be, that is the question.".endsWith('to be', 19)
HWTEST_F_L0(BuiltinsStringTest,endsWith3)552 HWTEST_F_L0(BuiltinsStringTest, endsWith3)
553 {
554 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
555 JSHandle<EcmaString> thisStr = factory->NewFromASCII("To be, or not to be, that is the question.");
556 JSHandle<EcmaString> val = factory->NewFromASCII("to be");
557
558 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
559 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
560 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
561 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
562 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(19)));
563
564 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
565 JSTaggedValue result = BuiltinsString::EndsWith(ecmaRuntimeCallInfo);
566
567 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
568 }
569
570 // "有ABC".toLocaleLowerCase()
HWTEST_F_L0(BuiltinsStringTest,toLocaleLowerCase2)571 HWTEST_F_L0(BuiltinsStringTest, toLocaleLowerCase2)
572 {
573 ASSERT_NE(thread, nullptr);
574 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
575 JSHandle<EcmaString> thisStr = factory->NewFromUtf8("有ABC");
576
577 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
578 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
579 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
580
581 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
582 JSTaggedValue result = BuiltinsString::ToLocaleLowerCase(ecmaRuntimeCallInfo);
583 ASSERT_TRUE(result.IsString());
584 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
585 JSHandle<EcmaString> test = factory->NewFromUtf8("有abc");
586 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
587 }
588
589 // "ABC".toLowerCase()
HWTEST_F_L0(BuiltinsStringTest,toLowerCase1)590 HWTEST_F_L0(BuiltinsStringTest, toLowerCase1)
591 {
592 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
593 JSHandle<EcmaString> thisStr = factory->NewFromASCII("ABC");
594
595 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
596 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
597 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
598
599 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
600 JSTaggedValue result = BuiltinsString::ToLowerCase(ecmaRuntimeCallInfo);
601 ASSERT_TRUE(result.IsString());
602 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
603 JSHandle<EcmaString> test = factory->NewFromASCII("abc");
604 ASSERT_TRUE(JSTaggedValue::SameValue(resultHandle.GetTaggedValue(), test.GetTaggedValue()));
605 }
606
607 // "abc".toUpperCase()
HWTEST_F_L0(BuiltinsStringTest,toUpperCase1)608 HWTEST_F_L0(BuiltinsStringTest, toUpperCase1)
609 {
610 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
611 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abc");
612
613 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
614 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
615 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
616
617 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
618 JSTaggedValue result = BuiltinsString::ToUpperCase(ecmaRuntimeCallInfo);
619 ASSERT_TRUE(result.IsString());
620 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
621 JSHandle<EcmaString> test = factory->NewFromASCII("ABC");
622 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
623 }
624
625 // "abc".localecompare('b')
HWTEST_F_L0(BuiltinsStringTest,localecompare1)626 HWTEST_F_L0(BuiltinsStringTest, localecompare1)
627 {
628 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
629 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abc");
630 JSHandle<EcmaString> val = factory->NewFromASCII("b");
631
632 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
633 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
634 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
635 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
636
637 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
638 JSTaggedValue result = BuiltinsString::LocaleCompare(ecmaRuntimeCallInfo);
639
640 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
641 }
642
643 // "abc".localecompare('abc')
HWTEST_F_L0(BuiltinsStringTest,localecompare2)644 HWTEST_F_L0(BuiltinsStringTest, localecompare2)
645 {
646 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
647 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abc");
648 JSHandle<EcmaString> val = factory->NewFromASCII("abc");
649
650 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
651 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
652 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
653 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
654
655 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
656 JSTaggedValue result = BuiltinsString::LocaleCompare(ecmaRuntimeCallInfo);
657
658 ASSERT_EQ(result.GetRawData(), JSTaggedValue(0).GetRawData());
659 }
660
661 // "abc".localecompare('aa')
HWTEST_F_L0(BuiltinsStringTest,localecompare3)662 HWTEST_F_L0(BuiltinsStringTest, localecompare3)
663 {
664 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
665 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abc");
666 JSHandle<EcmaString> val = factory->NewFromASCII("aa");
667
668 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
669 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
670 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
671 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
672
673 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
674 JSTaggedValue result = BuiltinsString::LocaleCompare(ecmaRuntimeCallInfo);
675
676 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
677 }
678
679 // "你好".localecompare('辅助')
HWTEST_F_L0(BuiltinsStringTest,localecompare4)680 HWTEST_F_L0(BuiltinsStringTest, localecompare4)
681 {
682 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
683 std::string referenceStr = "你好";
684 std::string compareStr = "辅助";
685 JSHandle<EcmaString> thisStr = factory->NewFromStdString(referenceStr);
686 JSHandle<EcmaString> val = factory->NewFromStdString(compareStr);
687 JSHandle<EcmaString> locale = factory->NewFromASCII("zh-Hans");
688
689 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
690 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
691 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
692 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
693 ecmaRuntimeCallInfo->SetCallArg(1, locale.GetTaggedValue());
694
695 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
696 JSTaggedValue result = BuiltinsString::LocaleCompare(ecmaRuntimeCallInfo);
697 TestHelper::TearDownFrame(thread, prev);
698
699 ASSERT_GT(result.GetRawData(), JSTaggedValue(0).GetRawData());
700 }
701
702 // Test localeCompare when locales changed
HWTEST_F_L0(BuiltinsStringTest,localecompare5)703 HWTEST_F_L0(BuiltinsStringTest, localecompare5)
704 {
705 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
706 std::string referenceStr = "ä";
707 std::string compareStr = "z";
708 JSHandle<EcmaString> thisStr = factory->NewFromStdString(referenceStr);
709 JSHandle<EcmaString> val = factory->NewFromStdString(compareStr);
710 JSHandle<EcmaString> locale = factory->NewFromASCII("de");
711
712 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
713 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
714 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
715 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
716 ecmaRuntimeCallInfo->SetCallArg(1, locale.GetTaggedValue());
717
718 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
719 JSTaggedValue result = BuiltinsString::LocaleCompare(ecmaRuntimeCallInfo);
720 TestHelper::TearDownFrame(thread, prev1);
721 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
722
723 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
724 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
725 ecmaRuntimeCallInfo1->SetThis(thisStr.GetTaggedValue());
726 ecmaRuntimeCallInfo1->SetCallArg(0, val.GetTaggedValue());
727 // change locale
728 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue::Undefined());
729 [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
730 JSTaggedValue result1 = BuiltinsString::LocaleCompare(ecmaRuntimeCallInfo1);
731 TestHelper::TearDownFrame(thread, prev2);
732 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(-1).GetRawData());
733 }
734
735 // "abc".normalize('NFC')
HWTEST_F_L0(BuiltinsStringTest,normalize1)736 HWTEST_F_L0(BuiltinsStringTest, normalize1)
737 {
738 ASSERT_NE(thread, nullptr);
739 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
740 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abc");
741 JSHandle<EcmaString> val = factory->NewFromASCII("NFC");
742
743 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
744 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
745 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
746 ecmaRuntimeCallInfo->SetCallArg(0, val.GetTaggedValue());
747
748 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
749 JSTaggedValue result = BuiltinsString::Normalize(ecmaRuntimeCallInfo);
750 ASSERT_TRUE(result.IsString());
751 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
752 JSHandle<EcmaString> test = factory->NewFromASCII("abc");
753 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
754 }
755
756 // "abc".repeat(5)
HWTEST_F_L0(BuiltinsStringTest,repeat1)757 HWTEST_F_L0(BuiltinsStringTest, repeat1)
758 {
759 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
760 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abc");
761
762 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
763 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
764 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
765 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(5)));
766
767 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
768 JSTaggedValue result = BuiltinsString::Repeat(ecmaRuntimeCallInfo);
769 ASSERT_TRUE(result.IsString());
770 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
771 JSHandle<EcmaString> test = factory->NewFromASCII("abcabcabcabcabc");
772 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
773 }
774
775 // 'The morning is upon us.'.slice(4, -2)
HWTEST_F_L0(BuiltinsStringTest,slice1)776 HWTEST_F_L0(BuiltinsStringTest, slice1)
777 {
778 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
779 JSHandle<EcmaString> thisStr = factory->NewFromASCII("The morning is upon us.");
780
781 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
782 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
783 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
784 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(4)));
785 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(-2)));
786
787 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
788 JSTaggedValue result = BuiltinsString::Slice(ecmaRuntimeCallInfo);
789 ASSERT_TRUE(result.IsString());
790 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
791 JSHandle<EcmaString> test = factory->NewFromASCII("morning is upon u");
792 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
793 }
794
795 // 'The morning is upon us.'.slice(12)
HWTEST_F_L0(BuiltinsStringTest,slice2)796 HWTEST_F_L0(BuiltinsStringTest, slice2)
797 {
798 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
799 JSHandle<EcmaString> thisStr = factory->NewFromASCII("The morning is upon us.");
800
801 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
802 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
803 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
804 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(12)));
805
806 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
807 JSTaggedValue result = BuiltinsString::Slice(ecmaRuntimeCallInfo);
808 ASSERT_TRUE(result.IsString());
809 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
810 JSHandle<EcmaString> test = factory->NewFromASCII("is upon us.");
811 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
812 }
813
814 // 'Mozilla'.substring(3, -3)
HWTEST_F_L0(BuiltinsStringTest,substring1)815 HWTEST_F_L0(BuiltinsStringTest, substring1)
816 {
817 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
818 JSHandle<EcmaString> thisStr = factory->NewFromASCII("Mozilla");
819
820 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
821 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
822 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
823 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(3)));
824 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(-3)));
825
826 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
827 JSTaggedValue result = BuiltinsString::Substring(ecmaRuntimeCallInfo);
828 ASSERT_TRUE(result.IsString());
829 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
830 JSHandle<EcmaString> test = factory->NewFromASCII("Moz");
831 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
832 }
833
834 // 'Mozilla'.substring(7, 4)
HWTEST_F_L0(BuiltinsStringTest,substring2)835 HWTEST_F_L0(BuiltinsStringTest, substring2)
836 {
837 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
838 JSHandle<EcmaString> thisStr = factory->NewFromASCII("Mozilla");
839
840 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
841 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
842 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
843 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(7)));
844 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(4)));
845
846 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
847 JSTaggedValue result = BuiltinsString::Substring(ecmaRuntimeCallInfo);
848 ASSERT_TRUE(result.IsString());
849 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
850 JSHandle<EcmaString> test = factory->NewFromASCII("lla");
851 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
852 }
853
854 // " Hello world! ".trim()
HWTEST_F_L0(BuiltinsStringTest,trim1)855 HWTEST_F_L0(BuiltinsStringTest, trim1)
856 {
857 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
858 JSHandle<EcmaString> thisStr = factory->NewFromASCII(" Hello world! ");
859
860 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
861 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
862 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
863
864 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
865 JSTaggedValue result = BuiltinsString::Trim(ecmaRuntimeCallInfo);
866 ASSERT_TRUE(result.IsString());
867 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
868 JSHandle<EcmaString> test = factory->NewFromASCII("Hello world!");
869 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
870 }
871
HWTEST_F_L0(BuiltinsStringTest,trim2)872 HWTEST_F_L0(BuiltinsStringTest, trim2)
873 {
874 auto ecmaVM = thread->GetEcmaVM();
875 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
876
877 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
878 JSHandle<EcmaString> thisStr = factory->NewFromASCII(" Hello world! ");
879 JSHandle<JSFunction> stringObject(env->GetStringFunction());
880 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(thisStr.GetTaggedValue().GetTaggedObject()));
881 JSHandle<JSPrimitiveRef> str = factory->NewJSPrimitiveRef(stringObject, value);
882
883 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
884 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
885 ecmaRuntimeCallInfo->SetThis(str.GetTaggedValue());
886
887 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
888 JSTaggedValue result = BuiltinsString::Trim(ecmaRuntimeCallInfo);
889 ASSERT_TRUE(result.IsString());
890 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
891 JSHandle<EcmaString> test = factory->NewFromASCII("Hello world!");
892 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
893 }
894
HWTEST_F_L0(BuiltinsStringTest,trimRight)895 HWTEST_F_L0(BuiltinsStringTest, trimRight)
896 {
897 auto ecmaVM = thread->GetEcmaVM();
898 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
899
900 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
901 JSHandle<EcmaString> thisStr = factory->NewFromASCII(" ");
902 JSHandle<JSFunction> stringObject(env->GetStringFunction());
903 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(thisStr.GetTaggedValue().GetTaggedObject()));
904 JSHandle<JSPrimitiveRef> str = factory->NewJSPrimitiveRef(stringObject, value);
905
906 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
907 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
908 ecmaRuntimeCallInfo->SetThis(str.GetTaggedValue());
909
910 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
911 JSTaggedValue result = BuiltinsString::TrimRight(ecmaRuntimeCallInfo);
912 ASSERT_TRUE(result.IsString());
913 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
914 JSHandle<EcmaString> test = factory->NewFromASCII("");
915 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
916 }
917
HWTEST_F_L0(BuiltinsStringTest,ToString)918 HWTEST_F_L0(BuiltinsStringTest, ToString)
919 {
920 auto ecmaVM = thread->GetEcmaVM();
921 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
922
923 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
924 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
925 JSHandle<JSFunction> stringObject(env->GetStringFunction());
926 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(thisStr.GetTaggedValue().GetTaggedObject()));
927 JSHandle<JSPrimitiveRef> str = factory->NewJSPrimitiveRef(stringObject, value);
928
929 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
930 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
931 ecmaRuntimeCallInfo->SetThis(str.GetTaggedValue());
932
933 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
934 JSTaggedValue result = BuiltinsString::ToString(ecmaRuntimeCallInfo);
935 ASSERT_TRUE(result.IsString());
936 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
937 JSTaggedValue test = JSTaggedValue(*thisStr);
938 ASSERT_EQ(result.GetRawData(), test.GetRawData());
939 }
940
HWTEST_F_L0(BuiltinsStringTest,ValueOf)941 HWTEST_F_L0(BuiltinsStringTest, ValueOf)
942 {
943 auto ecmaVM = thread->GetEcmaVM();
944 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
945
946 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
947 JSHandle<EcmaString> thisStr = factory->NewFromASCII("abcabcabc");
948 JSHandle<JSFunction> stringObject(env->GetStringFunction());
949 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(thisStr.GetTaggedValue().GetTaggedObject()));
950 JSHandle<JSPrimitiveRef> str = factory->NewJSPrimitiveRef(stringObject, value);
951
952 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
953 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
954 ecmaRuntimeCallInfo->SetThis(str.GetTaggedValue());
955
956 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
957 JSTaggedValue result = BuiltinsString::ValueOf(ecmaRuntimeCallInfo);
958 ASSERT_TRUE(result.IsString());
959 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
960 JSTaggedValue test = JSTaggedValue(*thisStr);
961 ASSERT_EQ(result.GetRawData(), test.GetRawData());
962 }
963
BuiltinsStringTestCreate(JSThread * thread)964 static inline JSFunction *BuiltinsStringTestCreate(JSThread *thread)
965 {
966 EcmaVM *ecmaVM = thread->GetEcmaVM();
967 JSHandle<GlobalEnv> globalEnv = ecmaVM->GetGlobalEnv();
968 return globalEnv->GetObjectFunction().GetObject<JSFunction>();
969 }
970
HWTEST_F_L0(BuiltinsStringTest,Raw)971 HWTEST_F_L0(BuiltinsStringTest, Raw)
972 {
973 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
974 JSHandle<JSTaggedValue> foo(factory->NewFromASCII("foo"));
975 JSHandle<JSTaggedValue> bar(factory->NewFromASCII("bar"));
976 JSHandle<JSTaggedValue> baz(factory->NewFromASCII("baz"));
977 JSHandle<JSTaggedValue> rawArray = JSHandle<JSTaggedValue>::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
978 JSHandle<JSObject> obj(rawArray);
979 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
980 PropertyDescriptor desc0(thread, foo);
981 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
982 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
983 PropertyDescriptor desc1(thread, bar);
984 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
985 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
986 PropertyDescriptor desc2(thread, baz);
987 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
988
989 JSHandle<JSTaggedValue> constructor(thread, BuiltinsStringTestCreate(thread));
990 JSHandle<JSTaggedValue> templateString(
991 factory->NewJSObjectByConstructor(JSHandle<JSFunction>(constructor), constructor));
992 JSHandle<JSTaggedValue> rawKey(factory->NewFromASCII("raw"));
993 JSObject::SetProperty(thread, templateString, rawKey, rawArray);
994 JSHandle<EcmaString> test = factory->NewFromASCII("foo5barJavaScriptbaz");
995
996 JSHandle<EcmaString> javascript = factory->NewFromASCII("JavaScript");
997
998 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
999 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1000 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1001 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(templateString.GetObject<EcmaString>()));
1002 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1003 ecmaRuntimeCallInfo->SetCallArg(2, javascript.GetTaggedValue());
1004
1005 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1006 JSTaggedValue result = BuiltinsString::Raw(ecmaRuntimeCallInfo);
1007 ASSERT_TRUE(result.IsString());
1008 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(reinterpret_cast<EcmaString *>(result.GetRawData()), *test));
1009 }
1010
HWTEST_F_L0(BuiltinsStringTest,Replace)1011 HWTEST_F_L0(BuiltinsStringTest, Replace)
1012 {
1013 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1014 JSHandle<EcmaString> thisStr = factory->NewFromASCII("Twas the night before Xmas...");
1015 JSHandle<EcmaString> searchStr = factory->NewFromASCII("Xmas");
1016 JSHandle<EcmaString> replaceStr = factory->NewFromASCII("Christmas");
1017 JSHandle<EcmaString> expected = factory->NewFromASCII("Twas the night before Christmas...");
1018
1019 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1020 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1021 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
1022 ecmaRuntimeCallInfo->SetCallArg(0, searchStr.GetTaggedValue());
1023 ecmaRuntimeCallInfo->SetCallArg(1, replaceStr.GetTaggedValue());
1024
1025 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1026 JSTaggedValue result = BuiltinsString::Replace(ecmaRuntimeCallInfo);
1027 TestHelper::TearDownFrame(thread, prev);
1028
1029 ASSERT_TRUE(result.IsString());
1030 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(reinterpret_cast<EcmaString *>(result.GetRawData()), *expected));
1031
1032 JSHandle<EcmaString> replaceStr1 = factory->NewFromASCII("abc$$");
1033 JSHandle<EcmaString> expected1 = factory->NewFromASCII("Twas the night before abc$...");
1034
1035 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1036 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1037 ecmaRuntimeCallInfo1->SetThis(thisStr.GetTaggedValue());
1038 ecmaRuntimeCallInfo1->SetCallArg(0, searchStr.GetTaggedValue());
1039 ecmaRuntimeCallInfo1->SetCallArg(1, replaceStr1.GetTaggedValue());
1040
1041 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1042 JSTaggedValue result1 = BuiltinsString::Replace(ecmaRuntimeCallInfo1);
1043 TestHelper::TearDownFrame(thread, prev);
1044
1045 JSHandle<EcmaString> resultString1(thread, result1);
1046 ASSERT_TRUE(result1.IsString());
1047 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString1, *expected1));
1048
1049 JSHandle<EcmaString> replaceStr2 = factory->NewFromASCII("abc$$dd");
1050 JSHandle<EcmaString> expected2 = factory->NewFromASCII("Twas the night before abc$dd...");
1051
1052 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1053 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1054 ecmaRuntimeCallInfo2->SetThis(thisStr.GetTaggedValue());
1055 ecmaRuntimeCallInfo2->SetCallArg(0, searchStr.GetTaggedValue());
1056 ecmaRuntimeCallInfo2->SetCallArg(1, replaceStr2.GetTaggedValue());
1057
1058 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1059 JSTaggedValue result2 = BuiltinsString::Replace(ecmaRuntimeCallInfo2);
1060 TestHelper::TearDownFrame(thread, prev);
1061
1062 JSHandle<EcmaString> resultString2(thread, result2);
1063 ASSERT_TRUE(result2.IsString());
1064 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString2, *expected2));
1065
1066 JSHandle<EcmaString> replaceStr3 = factory->NewFromASCII("abc$&dd");
1067 JSHandle<EcmaString> expected3 = factory->NewFromASCII("Twas the night before abcXmasdd...");
1068
1069 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1070 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1071 ecmaRuntimeCallInfo3->SetThis(thisStr.GetTaggedValue());
1072 ecmaRuntimeCallInfo3->SetCallArg(0, searchStr.GetTaggedValue());
1073 ecmaRuntimeCallInfo3->SetCallArg(1, replaceStr3.GetTaggedValue());
1074
1075 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1076 JSTaggedValue result3 = BuiltinsString::Replace(ecmaRuntimeCallInfo3);
1077 TestHelper::TearDownFrame(thread, prev);
1078
1079 JSHandle<EcmaString> resultString3(thread, result3);
1080 ASSERT_TRUE(result3.IsString());
1081 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString3, *expected3));
1082
1083 JSHandle<EcmaString> replaceStr4 = factory->NewFromASCII("abc$`dd");
1084 JSHandle<EcmaString> expected4 =
1085 factory->NewFromASCII("Twas the night before abcTwas the night before dd...");
1086
1087 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1088 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1089 ecmaRuntimeCallInfo4->SetThis(thisStr.GetTaggedValue());
1090 ecmaRuntimeCallInfo4->SetCallArg(0, searchStr.GetTaggedValue());
1091 ecmaRuntimeCallInfo4->SetCallArg(1, replaceStr4.GetTaggedValue());
1092
1093 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1094 JSTaggedValue result4 = BuiltinsString::Replace(ecmaRuntimeCallInfo4);
1095 TestHelper::TearDownFrame(thread, prev);
1096
1097 JSHandle<EcmaString> resultString4(thread, result4);
1098 ASSERT_TRUE(result4.IsString());
1099 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString4, *expected4));
1100 }
1101
HWTEST_F_L0(BuiltinsStringTest,Replace2)1102 HWTEST_F_L0(BuiltinsStringTest, Replace2)
1103 {
1104 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1105 JSHandle<EcmaString> thisStr = factory->NewFromASCII("Twas the night before Xmas...");
1106 JSHandle<EcmaString> searchStr = factory->NewFromASCII("Xmas");
1107 JSHandle<EcmaString> replaceStr = factory->NewFromASCII("abc$\'dd");
1108 JSHandle<EcmaString> expected = factory->NewFromASCII("Twas the night before abc...dd...");
1109
1110 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1111 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1112 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
1113 ecmaRuntimeCallInfo->SetCallArg(0, searchStr.GetTaggedValue());
1114 ecmaRuntimeCallInfo->SetCallArg(1, replaceStr.GetTaggedValue());
1115
1116 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1117 JSTaggedValue result = BuiltinsString::Replace(ecmaRuntimeCallInfo);
1118 TestHelper::TearDownFrame(thread, prev);
1119
1120 ASSERT_TRUE(result.IsString());
1121 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(reinterpret_cast<EcmaString *>(result.GetRawData()), *expected));
1122
1123 JSHandle<EcmaString> replaceStr2 = factory->NewFromASCII("abc$`dd$\'$ff");
1124 JSHandle<EcmaString> expected2 =
1125 factory->NewFromASCII("Twas the night before abcTwas the night before dd...$ff...");
1126
1127 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1128 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1129 ecmaRuntimeCallInfo2->SetThis(thisStr.GetTaggedValue());
1130 ecmaRuntimeCallInfo2->SetCallArg(0, searchStr.GetTaggedValue());
1131 ecmaRuntimeCallInfo2->SetCallArg(1, replaceStr2.GetTaggedValue());
1132
1133 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1134 JSTaggedValue result2 = BuiltinsString::Replace(ecmaRuntimeCallInfo2);
1135 TestHelper::TearDownFrame(thread, prev);
1136
1137 JSHandle<EcmaString> resultString2(thread, result2);
1138 ASSERT_TRUE(result2.IsString());
1139 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString2, *expected2));
1140
1141 JSHandle<EcmaString> replaceStr3 = factory->NewFromASCII("abc$`dd$\'$");
1142 JSHandle<EcmaString> expected3 =
1143 factory->NewFromASCII("Twas the night before abcTwas the night before dd...$...");
1144
1145 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1146 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1147 ecmaRuntimeCallInfo3->SetThis(thisStr.GetTaggedValue());
1148 ecmaRuntimeCallInfo3->SetCallArg(0, searchStr.GetTaggedValue());
1149 ecmaRuntimeCallInfo3->SetCallArg(1, replaceStr3.GetTaggedValue());
1150
1151 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1152 JSTaggedValue result3 = BuiltinsString::Replace(ecmaRuntimeCallInfo3);
1153 TestHelper::TearDownFrame(thread, prev);
1154
1155 JSHandle<EcmaString> resultString3(thread, result3);
1156 ASSERT_TRUE(result3.IsString());
1157 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString3, *expected3));
1158
1159 JSHandle<EcmaString> replaceStr4 = factory->NewFromASCII("abc$`dd$$");
1160 JSHandle<EcmaString> expected4 =
1161 factory->NewFromASCII("Twas the night before abcTwas the night before dd$...");
1162
1163 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1164 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1165 ecmaRuntimeCallInfo4->SetThis(thisStr.GetTaggedValue());
1166 ecmaRuntimeCallInfo4->SetCallArg(0, searchStr.GetTaggedValue());
1167 ecmaRuntimeCallInfo4->SetCallArg(1, replaceStr4.GetTaggedValue());
1168
1169 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1170 JSTaggedValue result4 = BuiltinsString::Replace(ecmaRuntimeCallInfo4);
1171 TestHelper::TearDownFrame(thread, prev);
1172
1173 ASSERT_TRUE(result4.IsString());
1174 JSHandle<EcmaString> resultString4(thread, result4);
1175 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*resultString4, *expected4));
1176 }
1177
HWTEST_F_L0(BuiltinsStringTest,Replace3)1178 HWTEST_F_L0(BuiltinsStringTest, Replace3)
1179 {
1180 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1181 JSHandle<EcmaString> thisStr = factory->NewFromASCII("Twas the night before Xmas...");
1182 JSHandle<EcmaString> searchStr = factory->NewFromASCII("Xmas");
1183 JSHandle<EcmaString> replaceStr = factory->NewFromASCII("$&a $` $\' $2 $01 $$1 $21 $32 a");
1184 JSHandle<EcmaString> expected = factory->NewFromASCII(
1185 "Twas the night before Xmasa Twas the night before ... $2 $01 $1 $21 $32 a...");
1186
1187 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1188 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1189 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
1190 ecmaRuntimeCallInfo->SetCallArg(0, searchStr.GetTaggedValue());
1191 ecmaRuntimeCallInfo->SetCallArg(1, replaceStr.GetTaggedValue());
1192
1193 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1194 JSTaggedValue result = BuiltinsString::Replace(ecmaRuntimeCallInfo);
1195
1196 ASSERT_TRUE(result.IsString());
1197 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(reinterpret_cast<EcmaString *>(result.GetRawData()), *expected));
1198 }
1199
HWTEST_F_L0(BuiltinsStringTest,Replace4)1200 HWTEST_F_L0(BuiltinsStringTest, Replace4)
1201 {
1202 // invoke RegExpConstructor method
1203 JSHandle<EcmaString> pattern1 =
1204 thread->GetEcmaVM()->GetFactory()->NewFromASCII("quick\\s(brown).+?(jumps)");
1205 JSHandle<EcmaString> flags1 = thread->GetEcmaVM()->GetFactory()->NewFromASCII("iug");
1206 JSTaggedValue result1 = CreateBuiltinsStringRegExpObjByPatternAndFlags(thread, pattern1, flags1);
1207 JSHandle<JSRegExp> searchStr(thread, reinterpret_cast<JSRegExp *>(result1.GetRawData()));
1208 JSHandle<EcmaString> expected = thread->GetEcmaVM()->GetFactory()->NewFromASCII(
1209 "The Quick Brown Fox Jumpsa The Over The Lazy Dog Jumps Brown $1 Jumps1 $32 a Over The Lazy Dog");
1210
1211 // make ecma_runtime_call_info2
1212 JSHandle<EcmaString> thisStr =
1213 thread->GetEcmaVM()->GetFactory()->NewFromASCII("The Quick Brown Fox Jumps Over The Lazy Dog");
1214 JSHandle<EcmaString> replaceStr =
1215 thread->GetEcmaVM()->GetFactory()->NewFromASCII("$&a $` $\' $2 $01 $$1 $21 $32 a");
1216
1217 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1218 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1219 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
1220 ecmaRuntimeCallInfo->SetCallArg(0, searchStr.GetTaggedValue());
1221 ecmaRuntimeCallInfo->SetCallArg(1, replaceStr.GetTaggedValue());
1222
1223 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1224 JSTaggedValue result = BuiltinsString::Replace(ecmaRuntimeCallInfo);
1225
1226 ASSERT_TRUE(result.IsString());
1227 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(reinterpret_cast<EcmaString *>(result.GetRawData()), *expected));
1228 }
1229
HWTEST_F_L0(BuiltinsStringTest,Split)1230 HWTEST_F_L0(BuiltinsStringTest, Split)
1231 {
1232 // invoke RegExpConstructor method
1233 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1234 JSHandle<EcmaString> thisStr = factory->NewFromASCII("Hello World. How are you doing?");
1235 JSHandle<EcmaString> separatorStr = factory->NewFromASCII(" ");
1236 JSHandle<JSTaggedValue> limit(thread, JSTaggedValue(3));
1237 JSHandle<EcmaString> expected1 = factory->NewFromASCII("Hello");
1238 JSHandle<EcmaString> expected2 = factory->NewFromASCII("World.");
1239 JSHandle<EcmaString> expected3 = factory->NewFromASCII("How");
1240
1241 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1242 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1243 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
1244 ecmaRuntimeCallInfo->SetCallArg(0, separatorStr.GetTaggedValue());
1245 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1246
1247 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1248 JSTaggedValue result = BuiltinsString::Split(ecmaRuntimeCallInfo);
1249
1250 ASSERT_TRUE(result.IsECMAObject());
1251 JSHandle<JSArray> resultArray(thread, reinterpret_cast<JSArray *>(result.GetRawData()));
1252 ASSERT_TRUE(resultArray->IsJSArray());
1253 JSHandle<JSTaggedValue> resultObj(resultArray);
1254 JSHandle<EcmaString> string1(
1255 JSObject::GetProperty(thread, resultObj, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))).GetValue());
1256 JSHandle<EcmaString> string2(
1257 JSObject::GetProperty(thread, resultObj, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))).GetValue());
1258 JSHandle<EcmaString> string3(
1259 JSObject::GetProperty(thread, resultObj, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))).GetValue());
1260 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*string1, *expected1));
1261 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*string2, *expected2));
1262 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*string3, *expected3));
1263 }
1264
HWTEST_F_L0(BuiltinsStringTest,Split2)1265 HWTEST_F_L0(BuiltinsStringTest, Split2)
1266 {
1267 // invoke RegExpConstructor method
1268 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1269 JSHandle<EcmaString> thisStr = factory->NewFromASCII("a-b-c");
1270 JSHandle<EcmaString> pattern1 = factory->NewFromASCII("-");
1271 JSHandle<EcmaString> flags1 = factory->NewFromASCII("iug");
1272 JSTaggedValue result1 = CreateBuiltinsStringRegExpObjByPatternAndFlags(thread, pattern1, flags1);
1273 JSHandle<JSRegExp> separatorObj(thread, result1);
1274
1275 JSHandle<JSTaggedValue> limit(thread, JSTaggedValue(3));
1276 JSHandle<EcmaString> expected1 = factory->NewFromASCII("a");
1277 JSHandle<EcmaString> expected2 = factory->NewFromASCII("b");
1278 JSHandle<EcmaString> expected3 = factory->NewFromASCII("c");
1279
1280 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1281 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1282 ecmaRuntimeCallInfo->SetThis(thisStr.GetTaggedValue());
1283 ecmaRuntimeCallInfo->SetCallArg(0, separatorObj.GetTaggedValue());
1284 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1285
1286 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1287 JSTaggedValue result = BuiltinsString::Split(ecmaRuntimeCallInfo);
1288
1289 ASSERT_TRUE(result.IsECMAObject());
1290 JSHandle<JSArray> resultArray(thread, result);
1291 ASSERT_TRUE(resultArray->IsJSArray());
1292 JSHandle<JSTaggedValue> resultObj(resultArray);
1293 JSHandle<EcmaString> string1(
1294 JSObject::GetProperty(thread, resultObj, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))).GetValue());
1295 JSHandle<EcmaString> string2(
1296 JSObject::GetProperty(thread, resultObj, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))).GetValue());
1297 JSHandle<EcmaString> string3(
1298 JSObject::GetProperty(thread, resultObj, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))).GetValue());
1299 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*string1, *expected1));
1300 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*string2, *expected2));
1301 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*string3, *expected3));
1302 }
1303
1304 // "一二三四".at(3)
HWTEST_F_L0(BuiltinsStringTest,at1)1305 HWTEST_F_L0(BuiltinsStringTest, at1)
1306 {
1307 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1308 JSHandle<EcmaString> thisVal = factory->NewFromUtf8("一二三四");
1309
1310 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1311 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1312 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
1313 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(3)));
1314
1315 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1316 JSTaggedValue result = BuiltinsString::At(ecmaRuntimeCallInfo);
1317 ASSERT_TRUE(result.IsString());
1318 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1319 JSHandle<EcmaString> test = factory->NewFromUtf8("四");
1320 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
1321 }
1322
1323 // "一二三四".at(-2)
HWTEST_F_L0(BuiltinsStringTest,at2)1324 HWTEST_F_L0(BuiltinsStringTest, at2)
1325 {
1326 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1327 JSHandle<EcmaString> thisVal = factory->NewFromUtf8("一二三四");
1328
1329 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1330 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1331 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
1332 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-2)));
1333
1334 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1335 JSTaggedValue result = BuiltinsString::At(ecmaRuntimeCallInfo);
1336 ASSERT_TRUE(result.IsString());
1337 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1338 JSHandle<EcmaString> test = factory->NewFromUtf8("三");
1339 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, test), 0);
1340 }
1341
1342 // "一二三四".at(-5)
HWTEST_F_L0(BuiltinsStringTest,at3)1343 HWTEST_F_L0(BuiltinsStringTest, at3)
1344 {
1345 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1346 JSHandle<EcmaString> thisVal = factory->NewFromUtf8("一二三四");
1347
1348 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1349 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1350 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
1351 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-5)));
1352
1353 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1354 JSTaggedValue result = BuiltinsString::At(ecmaRuntimeCallInfo);
1355 ASSERT_TRUE(result.IsUndefined());
1356 }
1357
1358 // "abcabcabc".at(9)
HWTEST_F_L0(BuiltinsStringTest,at4)1359 HWTEST_F_L0(BuiltinsStringTest, at4)
1360 {
1361 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1362 JSHandle<EcmaString> thisVal = factory->NewFromASCII("abcabcabc");
1363
1364 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1365 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1366 ecmaRuntimeCallInfo->SetThis(thisVal.GetTaggedValue());
1367 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(9)));
1368
1369 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1370 JSTaggedValue result = BuiltinsString::At(ecmaRuntimeCallInfo);
1371 ASSERT_TRUE(result.IsUndefined());
1372 }
1373 } // namespace panda::test
1374