1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/ecma_vm.h"
17 #include "ecmascript/global_env.h"
18 #include "ecmascript/js_bigint-inl.h"
19 #include "ecmascript/js_function.h"
20 #include "ecmascript/js_handle.h"
21 #include "ecmascript/js_hclass.h"
22 #include "ecmascript/js_object-inl.h"
23 #include "ecmascript/js_primitive_ref.h"
24 #include "ecmascript/js_symbol.h"
25 #include "ecmascript/js_tagged_value-inl.h"
26 #include "ecmascript/js_thread.h"
27 #include "ecmascript/object_factory-inl.h"
28 #include "ecmascript/snapshot/mem/snapshot.h"
29 #include "ecmascript/tests/test_helper.h"
30
31 using namespace panda::ecmascript;
32
33 namespace panda::test {
34 constexpr uint32_t TEST_NUMBER = 1;
35 constexpr uint32_t TEST_TAGGED_ARRAY_LENGTH = 1;
36 const std::string TEST_STRING = "testString";
37
38 class JSTaggedValueTest : public BaseTestWithScope<false> {
39 public:
NumberFromASCII(std::string_view data)40 JSTaggedNumber NumberFromASCII(std::string_view data)
41 {
42 JSHandle<JSTaggedValue> stringV(thread->GetEcmaVM()->GetFactory()->NewFromASCII(data));
43 return JSTaggedValue::ToNumber(thread, stringV);
44 }
45 };
46
HWTEST_F_L0(JSTaggedValueTest,Double)47 HWTEST_F_L0(JSTaggedValueTest, Double)
48 {
49 double d = 1.1;
50 JSTaggedValue td(d);
51 EXPECT_EQ(true, td.IsDouble());
52 EXPECT_EQ(false, td.IsInt());
53 EXPECT_EQ(false, td.IsObject());
54 ASSERT_DOUBLE_EQ(td.GetDouble(), d);
55
56 double nan = std::nan("");
57 JSTaggedValue tNan(nan);
58 EXPECT_EQ(true, tNan.IsDouble());
59 EXPECT_EQ(false, tNan.IsInt());
60 EXPECT_EQ(false, tNan.IsObject());
61 EXPECT_EQ(JSTaggedValue::CastDoubleToTagged(tNan.GetDouble()), JSTaggedValue::CastDoubleToTagged(nan));
62
63 double pureNaN = JSTaggedValue::CastTaggedToDouble(JSTaggedValue::TAG_INT - JSTaggedValue::DOUBLE_ENCODE_OFFSET);
64 EXPECT_EQ(true, JSTaggedValue::IsImpureNaN(pureNaN));
65 }
66
HWTEST_F_L0(JSTaggedValueTest,Int)67 HWTEST_F_L0(JSTaggedValueTest, Int)
68 {
69 int i = 0x5c;
70 JSTaggedValue t(0x5c);
71 EXPECT_EQ(true, t.IsInt());
72 EXPECT_EQ(false, t.IsObject());
73 EXPECT_EQ(false, t.IsDouble());
74 EXPECT_EQ(t.GetInt(), i);
75 }
76
HWTEST_F_L0(JSTaggedValueTest,IsObject)77 HWTEST_F_L0(JSTaggedValueTest, IsObject)
78 {
79 TaggedObject *p = reinterpret_cast<TaggedObject *>(0xffff0000UL);
80 JSTaggedValue t(p);
81 EXPECT_EQ(true, t.IsObject());
82 EXPECT_EQ(false, t.IsInt());
83 EXPECT_EQ(false, t.IsDouble());
84 EXPECT_EQ(t.GetTaggedObject(), p);
85 }
86
HWTEST_F_L0(JSTaggedValueTest,WeakRef)87 HWTEST_F_L0(JSTaggedValueTest, WeakRef)
88 {
89 TaggedObject *p = reinterpret_cast<TaggedObject *>(0xffff0000UL);
90 JSTaggedValue tInt(0x5c);
91 JSTaggedValue t(p);
92
93 t.CreateWeakRef();
94 EXPECT_EQ(false, tInt.IsWeak());
95 EXPECT_EQ(true, t.IsObject());
96 EXPECT_EQ(true, t.IsWeak());
97 EXPECT_EQ(false, t.IsInt());
98 EXPECT_EQ(false, t.IsDouble());
99 EXPECT_EQ(t.GetTaggedWeakRef(), p);
100 }
101
HWTEST_F_L0(JSTaggedValueTest,False)102 HWTEST_F_L0(JSTaggedValueTest, False)
103 {
104 JSTaggedValue t = JSTaggedValue::False();
105 EXPECT_EQ(t.IsFalse(), true);
106 }
107
HWTEST_F_L0(JSTaggedValueTest,True)108 HWTEST_F_L0(JSTaggedValueTest, True)
109 {
110 JSTaggedValue t = JSTaggedValue::True();
111 EXPECT_EQ(t.IsTrue(), true);
112 }
113
HWTEST_F_L0(JSTaggedValueTest,Undefined)114 HWTEST_F_L0(JSTaggedValueTest, Undefined)
115 {
116 JSTaggedValue t = JSTaggedValue::Undefined();
117 EXPECT_EQ(t.IsUndefined(), true);
118 }
HWTEST_F_L0(JSTaggedValueTest,Null)119 HWTEST_F_L0(JSTaggedValueTest, Null)
120 {
121 JSTaggedValue t = JSTaggedValue::Null();
122 EXPECT_EQ(t.IsNull(), true);
123 }
124
HWTEST_F_L0(JSTaggedValueTest,Hole)125 HWTEST_F_L0(JSTaggedValueTest, Hole)
126 {
127 JSTaggedValue t = JSTaggedValue::Hole();
128 EXPECT_EQ(t.IsHole(), true);
129 }
130
HWTEST_F_L0(JSTaggedValueTest,ToPrimitive)131 HWTEST_F_L0(JSTaggedValueTest, ToPrimitive)
132 {
133 JSTaggedValue result;
134
135 JSTaggedValue intV(100);
136 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, intV));
137 EXPECT_EQ(result.GetInt(), 100);
138
139 JSTaggedValue doubleV((double)100.0);
140 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, doubleV));
141 EXPECT_EQ(result.GetDouble(), (double)100.0);
142
143 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
144 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
145 EXPECT_TRUE(result.IsUndefined());
146
147 JSTaggedValue holeV = JSTaggedValue::Hole();
148 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, holeV));
149 EXPECT_TRUE(result.IsHole());
150
151 JSTaggedValue nullV = JSTaggedValue::Null();
152 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, nullV));
153 EXPECT_TRUE(result.IsNull());
154
155 JSTaggedValue falseV = JSTaggedValue::False();
156 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, falseV));
157 EXPECT_TRUE(result.IsFalse());
158
159 JSTaggedValue trueV = JSTaggedValue::True();
160 result = JSTaggedValue::ToPrimitive(thread, JSHandle<JSTaggedValue>(thread, trueV));
161 EXPECT_TRUE(result.IsTrue());
162 }
163
HWTEST_F_L0(JSTaggedValueTest,ToBoolean)164 HWTEST_F_L0(JSTaggedValueTest, ToBoolean)
165 {
166 EXPECT_TRUE(JSTaggedValue(100).ToBoolean());
167 EXPECT_FALSE(JSTaggedValue(0).ToBoolean());
168
169 EXPECT_TRUE(JSTaggedValue((double)100.0).ToBoolean());
170 EXPECT_FALSE(JSTaggedValue(std::nan("")).ToBoolean());
171
172 EXPECT_FALSE(JSTaggedValue::Undefined().ToBoolean());
173
174 EXPECT_FALSE(JSTaggedValue::Hole().ToBoolean());
175
176 EXPECT_FALSE(JSTaggedValue::Null().ToBoolean());
177
178 EXPECT_FALSE(JSTaggedValue::False().ToBoolean());
179 EXPECT_TRUE(JSTaggedValue::True().ToBoolean());
180
181 EXPECT_FALSE(thread->GetEcmaVM()->GetFactory()->GetEmptyString().GetTaggedValue().ToBoolean());
182 EXPECT_TRUE(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test").GetTaggedValue().ToBoolean());
183 }
184
HWTEST_F_L0(JSTaggedValueTest,ToNumber)185 HWTEST_F_L0(JSTaggedValueTest, ToNumber)
186 {
187 JSTaggedNumber result;
188
189 JSTaggedValue intV(100);
190 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, intV));
191 EXPECT_EQ(result.GetNumber(), 100);
192
193 JSTaggedValue doubleV((double)100.0);
194 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, doubleV));
195 EXPECT_EQ(result.GetNumber(), (double)100.0);
196
197 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
198 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
199 EXPECT_TRUE(std::isnan(result.GetNumber()));
200
201 JSTaggedValue holeV = JSTaggedValue::Hole();
202 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, holeV));
203 EXPECT_TRUE(std::isnan(result.GetNumber()));
204
205 JSTaggedValue nullV = JSTaggedValue::Null();
206 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, nullV));
207 EXPECT_EQ(result.GetNumber(), 0);
208
209 JSTaggedValue falseV = JSTaggedValue::False();
210 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, falseV));
211 EXPECT_EQ(result.GetNumber(), 0);
212
213 JSTaggedValue trueV = JSTaggedValue::True();
214 result = JSTaggedValue::ToNumber(thread, JSHandle<JSTaggedValue>(thread, trueV));
215 EXPECT_EQ(result.GetNumber(), 1);
216
217 thread->ClearException();
218 JSHandle<JSTaggedValue> symbolV1(thread->GetEcmaVM()->GetFactory()->NewJSSymbol());
219 JSTaggedValue::ToNumber(thread, symbolV1);
220 EXPECT_TRUE(thread->HasPendingException());
221 EXPECT_TRUE(thread->GetException().IsJSError());
222 }
223
HWTEST_F_L0(JSTaggedValueTest,StringToNumber)224 HWTEST_F_L0(JSTaggedValueTest, StringToNumber)
225 {
226 EXPECT_EQ(NumberFromASCII(" 1234 ").GetNumber(), 1234);
227 EXPECT_EQ(NumberFromASCII(" 0b1010 ").GetNumber(), 10);
228 EXPECT_EQ(NumberFromASCII(" 0O11 ").GetNumber(), 9);
229 EXPECT_EQ(NumberFromASCII(" 0x2d ").GetNumber(), 45);
230 EXPECT_EQ(NumberFromASCII(" 0.000001 ").GetNumber(), 0.000001);
231 EXPECT_EQ(NumberFromASCII(" 1.23 ").GetNumber(), 1.23);
232 EXPECT_EQ(NumberFromASCII(" -1.23e2 ").GetNumber(), -123);
233 EXPECT_EQ(NumberFromASCII(" -123e-2").GetNumber(), -1.23);
234 EXPECT_TRUE(std::isinf(NumberFromASCII(" Infinity ").GetNumber()));
235 EXPECT_TRUE(std::isinf(NumberFromASCII("100e307").GetNumber()));
236 EXPECT_TRUE(std::isnan(NumberFromASCII(" .").GetNumber()));
237 EXPECT_TRUE(std::isnan(NumberFromASCII("12e+").GetNumber()));
238 EXPECT_TRUE(std::isnan(NumberFromASCII(".e3").GetNumber()));
239 EXPECT_TRUE(std::isnan(NumberFromASCII("23eE").GetNumber()));
240 EXPECT_TRUE(std::isnan(NumberFromASCII("a").GetNumber()));
241 EXPECT_TRUE(std::isnan(NumberFromASCII("0o12e3").GetNumber()));
242 EXPECT_TRUE(std::isnan(NumberFromASCII("0x12.3").GetNumber()));
243 EXPECT_TRUE(std::isnan(NumberFromASCII(" 12.4.").GetNumber()));
244 EXPECT_TRUE(std::isnan(NumberFromASCII("123test").GetNumber()));
245 EXPECT_TRUE(std::isnan(NumberFromASCII(" 0b ").GetNumber()));
246 EXPECT_EQ(NumberFromASCII(" 0b0000 ").GetNumber(), 0);
247 EXPECT_EQ(NumberFromASCII(" 0o0000 ").GetNumber(), 0);
248 EXPECT_EQ(NumberFromASCII(" 0X0000 ").GetNumber(), 0);
249 EXPECT_EQ(NumberFromASCII(" 000.00000 ").GetNumber(), 0);
250 EXPECT_EQ(NumberFromASCII("").GetNumber(), 0);
251 EXPECT_EQ(NumberFromASCII(" ").GetNumber(), 0);
252 EXPECT_EQ(NumberFromASCII("0").GetNumber(), 0);
253 EXPECT_EQ(NumberFromASCII(" 0 ").GetNumber(), 0);
254 EXPECT_EQ(NumberFromASCII("00000000").GetNumber(), 0);
255 EXPECT_EQ(NumberFromASCII(" 00000000 ").GetNumber(), 0);
256 EXPECT_EQ(NumberFromASCII(" 000. ").GetNumber(), 0);
257 EXPECT_EQ(NumberFromASCII(" 123. ").GetNumber(), 123);
258 }
259
HWTEST_F_L0(JSTaggedValueTest,ToInteger)260 HWTEST_F_L0(JSTaggedValueTest, ToInteger)
261 {
262 JSTaggedNumber result;
263
264 JSTaggedValue intV(100);
265 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, intV));
266 EXPECT_EQ(result.GetNumber(), 100);
267
268 JSTaggedValue doubleV1((double)100.0);
269 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
270 EXPECT_EQ(result.GetNumber(), (double)100.0);
271
272 JSTaggedValue doubleV2((double)100.123);
273 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
274 EXPECT_EQ(result.GetNumber(), (double)100);
275
276 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
277 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
278 EXPECT_EQ(result.GetNumber(), 0);
279
280 JSTaggedValue holeV = JSTaggedValue::Hole();
281 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, holeV));
282 EXPECT_EQ(result.GetNumber(), 0);
283
284 JSTaggedValue nullV = JSTaggedValue::Null();
285 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, nullV));
286 EXPECT_EQ(result.GetNumber(), 0);
287
288 JSTaggedValue falseV = JSTaggedValue::False();
289 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, falseV));
290 EXPECT_EQ(result.GetNumber(), 0);
291
292 JSTaggedValue trueV = JSTaggedValue::True();
293 result = JSTaggedValue::ToInteger(thread, JSHandle<JSTaggedValue>(thread, trueV));
294 EXPECT_EQ(result.GetNumber(), 1);
295 }
296
HWTEST_F_L0(JSTaggedValueTest,ToInt32)297 HWTEST_F_L0(JSTaggedValueTest, ToInt32)
298 {
299 int32_t result;
300
301 JSTaggedValue intV(100);
302 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, intV));
303 EXPECT_EQ(result, 100);
304
305 JSTaggedValue doubleV1((double)100.0);
306 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
307 EXPECT_EQ(result, 100);
308
309 JSTaggedValue doubleV2((double)100.123);
310 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
311 EXPECT_EQ(result, 100);
312
313 double input1 = (static_cast<uint64_t>(UINT32_MAX) + 1) + 12345;
314 JSTaggedValue doubleV3(input1);
315 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
316 EXPECT_EQ(result, 12345);
317
318 double input2 = 100 * (static_cast<uint64_t>(UINT32_MAX) + 1) + 23456;
319 JSTaggedValue doubleV4(input2);
320 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
321 EXPECT_EQ(result, 23456);
322
323 double input3 = 100 * (static_cast<uint64_t>(UINT32_MAX) + 1) + INT32_MAX + 1 + 23456;
324 JSTaggedValue doubleV5(input3);
325 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
326 EXPECT_EQ(result, 23456 - static_cast<int32_t>(INT32_MAX) - 1);
327
328 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
329 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
330 EXPECT_EQ(result, 0);
331
332 JSTaggedValue holeV = JSTaggedValue::Hole();
333 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, holeV));
334 EXPECT_EQ(result, 0);
335
336 JSTaggedValue nullV = JSTaggedValue::Null();
337 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, nullV));
338 EXPECT_EQ(result, 0);
339
340 JSTaggedValue falseV = JSTaggedValue::False();
341 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, falseV));
342 EXPECT_EQ(result, 0);
343
344 JSTaggedValue trueV = JSTaggedValue::True();
345 result = JSTaggedValue::ToInt32(thread, JSHandle<JSTaggedValue>(thread, trueV));
346 EXPECT_EQ(result, 1);
347 }
348
HWTEST_F_L0(JSTaggedValueTest,ToUint32)349 HWTEST_F_L0(JSTaggedValueTest, ToUint32)
350 {
351 uint32_t result;
352
353 JSTaggedValue intV(100);
354 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, intV));
355 EXPECT_EQ(result, 100U);
356
357 JSTaggedValue doubleV1((double)100.0);
358 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
359 EXPECT_EQ(result, 100U);
360
361 JSTaggedValue doubleV2((double)100.123);
362 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
363 EXPECT_EQ(result, 100U);
364
365 double input1 = (static_cast<uint64_t>(UINT32_MAX) + 1) + 12345;
366 JSTaggedValue doubleV3(input1);
367 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
368 EXPECT_EQ(result, 12345U);
369
370 double input2 = 100 * (static_cast<uint64_t>(UINT32_MAX) + 1) + 23456;
371 JSTaggedValue doubleV4(input2);
372 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
373 EXPECT_EQ(result, 23456U);
374
375 double input3 = 100 * (static_cast<uint64_t>(UINT32_MAX) + 1) + INT32_MAX + 1 + 23456;
376 JSTaggedValue doubleV5(input3);
377 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
378 EXPECT_EQ(result, static_cast<uint32_t>(static_cast<uint64_t>(INT32_MAX) + 1 + 23456));
379
380 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
381 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
382 EXPECT_EQ(result, 0U);
383
384 JSTaggedValue holeV = JSTaggedValue::Hole();
385 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, holeV));
386 EXPECT_EQ(result, 0U);
387
388 JSTaggedValue nullV = JSTaggedValue::Null();
389 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, nullV));
390 EXPECT_EQ(result, 0U);
391
392 JSTaggedValue falseV = JSTaggedValue::False();
393 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, falseV));
394 EXPECT_EQ(result, 0U);
395
396 JSTaggedValue trueV = JSTaggedValue::True();
397 result = JSTaggedValue::ToUint32(thread, JSHandle<JSTaggedValue>(thread, trueV));
398 EXPECT_EQ(result, 1U);
399 }
400
HWTEST_F_L0(JSTaggedValueTest,ToInt16)401 HWTEST_F_L0(JSTaggedValueTest, ToInt16)
402 {
403 int32_t result;
404
405 JSTaggedValue intV(100);
406 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, intV));
407 EXPECT_EQ(result, 100);
408
409 JSTaggedValue doubleV1((double)100.0);
410 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
411 EXPECT_EQ(result, 100);
412
413 JSTaggedValue doubleV2((double)100.123);
414 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
415 EXPECT_EQ(result, 100);
416
417 double input1 = (static_cast<uint64_t>(UINT16_MAX) + 1) + 12345;
418 JSTaggedValue doubleV3(input1);
419 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
420 EXPECT_EQ(result, 12345);
421
422 double input2 = 100 * (static_cast<uint64_t>(UINT16_MAX) + 1) + 23456;
423 JSTaggedValue doubleV4(input2);
424 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
425 EXPECT_EQ(result, 23456);
426
427 double input3 = 100 * (static_cast<uint64_t>(UINT16_MAX) + 1) + INT16_MAX + 1 + 23456;
428 JSTaggedValue doubleV5(input3);
429 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
430 EXPECT_EQ(result, 23456 - static_cast<int32_t>(INT16_MAX) - 1);
431
432 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
433 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
434 EXPECT_EQ(result, 0);
435
436 JSTaggedValue holeV = JSTaggedValue::Hole();
437 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, holeV));
438 EXPECT_EQ(result, 0);
439
440 JSTaggedValue nullV = JSTaggedValue::Null();
441 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, nullV));
442 EXPECT_EQ(result, 0);
443
444 JSTaggedValue falseV = JSTaggedValue::False();
445 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, falseV));
446 EXPECT_EQ(result, 0);
447
448 JSTaggedValue trueV = JSTaggedValue::True();
449 result = JSTaggedValue::ToInt16(thread, JSHandle<JSTaggedValue>(thread, trueV));
450 EXPECT_EQ(result, 1);
451 }
452
HWTEST_F_L0(JSTaggedValueTest,ToUint16)453 HWTEST_F_L0(JSTaggedValueTest, ToUint16)
454 {
455 uint32_t result;
456
457 JSTaggedValue intV(100);
458 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, intV));
459 EXPECT_EQ(result, 100U);
460
461 JSTaggedValue doubleV1((double)100.0);
462 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
463 EXPECT_EQ(result, 100U);
464
465 JSTaggedValue doubleV2((double)100.123);
466 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
467 EXPECT_EQ(result, 100U);
468
469 double input1 = (static_cast<uint64_t>(UINT16_MAX) + 1) + 12345;
470 JSTaggedValue doubleV3(input1);
471 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
472 EXPECT_EQ(result, 12345U);
473
474 double input2 = 100 * (static_cast<uint64_t>(UINT16_MAX) + 1) + 23456;
475 JSTaggedValue doubleV4(input2);
476 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
477 EXPECT_EQ(result, 23456U);
478
479 double input3 = 100 * (static_cast<uint64_t>(UINT16_MAX) + 1) + INT16_MAX + 1 + 23456;
480 JSTaggedValue doubleV5(input3);
481 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
482 EXPECT_EQ(result, static_cast<uint64_t>(INT16_MAX + 1 + 23456));
483
484 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
485 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
486 EXPECT_EQ(result, 0U);
487
488 JSTaggedValue holeV = JSTaggedValue::Hole();
489 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, holeV));
490 EXPECT_EQ(result, 0U);
491
492 JSTaggedValue nullV = JSTaggedValue::Null();
493 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, nullV));
494 EXPECT_EQ(result, 0U);
495
496 JSTaggedValue falseV = JSTaggedValue::False();
497 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, falseV));
498 EXPECT_EQ(result, 0U);
499
500 JSTaggedValue trueV = JSTaggedValue::True();
501 result = JSTaggedValue::ToUint16(thread, JSHandle<JSTaggedValue>(thread, trueV));
502 EXPECT_EQ(result, 1U);
503 }
504
HWTEST_F_L0(JSTaggedValueTest,ToInt8)505 HWTEST_F_L0(JSTaggedValueTest, ToInt8)
506 {
507 int32_t result;
508
509 JSTaggedValue intV(100);
510 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, intV));
511 EXPECT_EQ(result, 100);
512
513 JSTaggedValue doubleV1((double)100.0);
514 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
515 EXPECT_EQ(result, 100);
516
517 JSTaggedValue doubleV2((double)100.123);
518 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
519 EXPECT_EQ(result, 100);
520
521 double input1 = (static_cast<uint64_t>(UINT8_MAX) + 1) + 45;
522 JSTaggedValue doubleV3(input1);
523 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
524 EXPECT_EQ(result, 45);
525
526 double input2 = 100 * (static_cast<uint64_t>(UINT8_MAX) + 1) + 56;
527 JSTaggedValue doubleV4(input2);
528 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
529 EXPECT_EQ(result, 56);
530
531 double input3 = 100 * (static_cast<uint64_t>(UINT8_MAX) + 1) + INT8_MAX + 1 + 23;
532 JSTaggedValue doubleV5(input3);
533 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
534 EXPECT_EQ(result, 23 - static_cast<int32_t>(INT8_MAX) - 1);
535
536 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
537 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
538 EXPECT_EQ(result, 0);
539
540 JSTaggedValue holeV = JSTaggedValue::Hole();
541 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, holeV));
542 EXPECT_EQ(result, 0);
543
544 JSTaggedValue nullV = JSTaggedValue::Null();
545 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, nullV));
546 EXPECT_EQ(result, 0);
547
548 JSTaggedValue falseV = JSTaggedValue::False();
549 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, falseV));
550 EXPECT_EQ(result, 0);
551
552 JSTaggedValue trueV = JSTaggedValue::True();
553 result = JSTaggedValue::ToInt8(thread, JSHandle<JSTaggedValue>(thread, trueV));
554 EXPECT_EQ(result, 1);
555 }
556
HWTEST_F_L0(JSTaggedValueTest,ToUint8)557 HWTEST_F_L0(JSTaggedValueTest, ToUint8)
558 {
559 uint32_t result;
560
561 JSTaggedValue intV(100);
562 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, intV));
563 EXPECT_EQ(result, 100U);
564
565 JSTaggedValue doubleV1((double)100.0);
566 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
567 EXPECT_EQ(result, 100U);
568
569 JSTaggedValue doubleV2((double)100.123);
570 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
571 EXPECT_EQ(result, 100U);
572
573 double input1 = (static_cast<uint64_t>(UINT8_MAX) + 1) + 34;
574 JSTaggedValue doubleV3(input1);
575 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
576 EXPECT_EQ(result, 34U);
577
578 double input2 = 100 * (static_cast<uint64_t>(UINT8_MAX) + 1) + 45;
579 JSTaggedValue doubleV4(input2);
580 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
581 EXPECT_EQ(result, 45U);
582
583 double input3 = 100 * (static_cast<uint64_t>(UINT8_MAX) + 1) + INT8_MAX + 1 + 56;
584 JSTaggedValue doubleV5(input3);
585 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
586 EXPECT_EQ(result, static_cast<uint64_t>(INT8_MAX + 1 + 56));
587
588 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
589 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
590 EXPECT_EQ(result, 0U);
591
592 JSTaggedValue holeV = JSTaggedValue::Hole();
593 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, holeV));
594 EXPECT_EQ(result, 0U);
595
596 JSTaggedValue nullV = JSTaggedValue::Null();
597 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, nullV));
598 EXPECT_EQ(result, 0U);
599
600 JSTaggedValue falseV = JSTaggedValue::False();
601 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, falseV));
602 EXPECT_EQ(result, 0U);
603
604 JSTaggedValue trueV = JSTaggedValue::True();
605 result = JSTaggedValue::ToUint8(thread, JSHandle<JSTaggedValue>(thread, trueV));
606 EXPECT_EQ(result, 1U);
607 }
608
HWTEST_F_L0(JSTaggedValueTest,ToUint8Clamp)609 HWTEST_F_L0(JSTaggedValueTest, ToUint8Clamp)
610 {
611 uint32_t result;
612
613 JSTaggedValue intV1(-100);
614 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, intV1));
615 EXPECT_EQ(result, 0U);
616
617 JSTaggedValue intV2(100);
618 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, intV2));
619 EXPECT_EQ(result, 100U);
620
621 JSTaggedValue intV3(300);
622 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, intV3));
623 EXPECT_EQ(result, 255U);
624
625 JSTaggedValue doubleV1((double)-100.123);
626 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
627 EXPECT_EQ(result, 0U);
628
629 JSTaggedValue doubleV2((double)100.123);
630 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
631 EXPECT_EQ(result, 100U);
632
633 JSTaggedValue doubleV3((double)100.55);
634 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
635 EXPECT_EQ(result, 101U);
636
637 JSTaggedValue doubleV4((double)99.9);
638 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
639 EXPECT_EQ(result, 100U);
640
641 JSTaggedValue doubleV5((double)300.5);
642 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, doubleV5));
643 EXPECT_EQ(result, 255U);
644
645 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
646 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
647 EXPECT_EQ(result, 0U);
648
649 JSTaggedValue holeV = JSTaggedValue::Hole();
650 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, holeV));
651 EXPECT_EQ(result, 0U);
652
653 JSTaggedValue nullV = JSTaggedValue::Null();
654 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, nullV));
655 EXPECT_EQ(result, 0U);
656
657 JSTaggedValue falseV = JSTaggedValue::False();
658 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, falseV));
659 EXPECT_EQ(result, 0U);
660
661 JSTaggedValue trueV = JSTaggedValue::True();
662 result = JSTaggedValue::ToUint8Clamp(thread, JSHandle<JSTaggedValue>(thread, trueV));
663 EXPECT_EQ(result, 1U);
664 }
665
HWTEST_F_L0(JSTaggedValueTest,ToPropertyKey)666 HWTEST_F_L0(JSTaggedValueTest, ToPropertyKey)
667 {
668 JSTaggedValue result;
669 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("null");
670 JSTaggedValue key = str.GetTaggedValue();
671 result = JSTaggedValue::ToPropertyKey(thread, JSHandle<JSTaggedValue>(thread, key)).GetTaggedValue();
672 EXPECT_TRUE(key == result);
673 }
674
CheckOkString(JSThread * thread,const JSHandle<JSTaggedValue> & tagged,CString & rightCStr)675 void CheckOkString(JSThread *thread, const JSHandle<JSTaggedValue> &tagged, CString &rightCStr)
676 {
677 JSHandle<EcmaString> result = JSTaggedValue::ToString(thread, tagged);
678 JSHandle<EcmaString> rightString = thread->GetEcmaVM()->GetFactory()->NewFromASCII(rightCStr);
679 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(thread, EcmaString::Cast(result.GetObject<EcmaString>()),
680 EcmaString::Cast(rightString.GetObject<EcmaString>())));
681 }
682
HWTEST_F_L0(JSTaggedValueTest,ToString)683 HWTEST_F_L0(JSTaggedValueTest, ToString)
684 {
685 CString rightCStr = "";
686 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue()), rightCStr);
687
688 rightCStr = "undefined";
689 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined()), rightCStr);
690
691 rightCStr = "null";
692 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()), rightCStr);
693
694 rightCStr = "true";
695 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()), rightCStr);
696
697 rightCStr = "false";
698 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()), rightCStr);
699
700 rightCStr = "hello world";
701 CheckOkString(thread,
702 JSHandle<JSTaggedValue>(thread->GetEcmaVM()->GetFactory()->NewFromASCII(rightCStr)),
703 rightCStr);
704
705 double num = 1;
706 JSTaggedNumber numberNum = JSTaggedNumber(num);
707 rightCStr = "1";
708 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, numberNum), rightCStr);
709
710 num = 1.23;
711 numberNum = JSTaggedNumber(num);
712 rightCStr = "1.23";
713 CheckOkString(thread, JSHandle<JSTaggedValue>(thread, numberNum), rightCStr);
714
715 int numInt = 2;
716 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(numInt));
717 rightCStr = "2";
718 CheckOkString(thread, JSHandle<JSTaggedValue>::Cast(JSTaggedValue::ToObject(thread, value1)), rightCStr);
719
720 num = 1.23;
721 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(num));
722 rightCStr = "1.23";
723 CheckOkString(thread, JSHandle<JSTaggedValue>::Cast(JSTaggedValue::ToObject(thread, value2)), rightCStr);
724
725 bool valueBool = true;
726 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(valueBool));
727 rightCStr = "true";
728 CheckOkString(thread, JSHandle<JSTaggedValue>::Cast(JSTaggedValue::ToObject(thread, value3)), rightCStr);
729 }
730
CheckOkExceptionString(JSThread * thread,const JSHandle<JSTaggedValue> & tagged,std::string & rightCStr)731 void CheckOkExceptionString(JSThread *thread, const JSHandle<JSTaggedValue> &tagged, std::string &rightCStr)
732 {
733 std::string result = JSTaggedValue::ExceptionToString(thread, tagged);
734 EXPECT_EQ(result, rightCStr);
735 }
736
HWTEST_F_L0(JSTaggedValueTest,ExceptionToString)737 HWTEST_F_L0(JSTaggedValueTest, ExceptionToString)
738 {
739 std::string rightCStr = "";
740 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue()), rightCStr);
741
742 JSHandle<JSSymbol> symbol = thread->GetEcmaVM()->GetFactory()->NewJSSymbol();
743 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>::Cast(symbol), rightCStr);
744
745 rightCStr = "undefined";
746 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined()), rightCStr);
747
748 rightCStr = "null";
749 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()), rightCStr);
750
751 rightCStr = "true";
752 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()), rightCStr);
753
754 rightCStr = "false";
755 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()), rightCStr);
756
757 rightCStr = "hello world";
758 CheckOkExceptionString(thread,
759 JSHandle<JSTaggedValue>(thread->GetEcmaVM()->GetFactory()->NewFromASCII(rightCStr)),
760 rightCStr);
761 }
762
HWTEST_F_L0(JSTaggedValueTest,ExceptionToString1)763 HWTEST_F_L0(JSTaggedValueTest, ExceptionToString1)
764 {
765 std::string rightCStr = "1";
766 double num = 1;
767 JSTaggedNumber numberNum = JSTaggedNumber(num);
768 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, numberNum), rightCStr);
769
770 num = 1.23;
771 numberNum = JSTaggedNumber(num);
772 rightCStr = "1.23";
773 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>(thread, numberNum), rightCStr);
774
775 int numInt = 2;
776 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(numInt));
777 rightCStr = "2";
778 CheckOkExceptionString(thread, value1, rightCStr);
779
780 rightCStr = "4294967295";
781 JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, 2);
782 newBigint->SetDigit(0, std::numeric_limits<uint32_t>::max());
783 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>::Cast(newBigint), rightCStr);
784
785 num = 1.23;
786 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(num));
787 rightCStr = "1.23";
788 CheckOkExceptionString(thread, value2, rightCStr);
789
790 bool valueBool = true;
791 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(valueBool));
792 rightCStr = "true";
793 CheckOkExceptionString(thread, value3, rightCStr);
794
795 JSHandle<JSTaggedValue> value4(thread, JSTaggedValue(valueBool));
796 rightCStr = "Object";
797 CheckOkExceptionString(thread, JSHandle<JSTaggedValue>::Cast(JSTaggedValue::ToObject(thread, value4)), rightCStr);
798
799 auto *newBitSetVector = new std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>>();
800 auto deleter = []([[maybe_unused]] void *env, void *pointer, [[maybe_unused]] void *data) {
801 if (pointer == nullptr) {
802 return;
803 }
804 delete reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(pointer);
805 };
806 JSHandle<JSNativePointer> pointer = thread->GetEcmaVM()->GetFactory()->NewSJSNativePointer(
807 newBitSetVector, deleter, newBitSetVector);
808 std::string result = JSTaggedValue::ExceptionToString(thread, JSHandle<JSTaggedValue>::Cast(pointer));
809 EXPECT_EQ(result.find("[External:") != std::string::npos, true);
810 }
811
HWTEST_F_L0(JSTaggedValueTest,CanonicalNumericIndexString)812 HWTEST_F_L0(JSTaggedValueTest, CanonicalNumericIndexString)
813 {
814 JSTaggedValue result;
815 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("-0");
816 JSTaggedValue tmpStr = str.GetTaggedValue();
817 result = JSTaggedValue::CanonicalNumericIndexString(thread, JSHandle<JSTaggedValue>(thread, tmpStr));
818 EXPECT_EQ(result.GetDouble(), -0.0);
819
820 JSHandle<JSTaggedValue> undefinedHandle(thread, JSTaggedValue::Undefined());
821 JSHandle<JSTaggedValue> key1 = JSTaggedValue::ToPropertyKey(thread, undefinedHandle);
822 result = JSTaggedValue::CanonicalNumericIndexString(thread, key1);
823 EXPECT_TRUE(result.IsUndefined());
824 }
825
HWTEST_F_L0(JSTaggedValueTest,ToObject)826 HWTEST_F_L0(JSTaggedValueTest, ToObject)
827 {
828 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
829
830 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(2));
831 JSTaggedValue tagged1 =
832 JSTaggedValue(JSHandle<JSPrimitiveRef>::Cast(JSTaggedValue::ToObject(thread, value1))->GetValue(thread));
833 EXPECT_EQ(tagged1.GetRawData(), JSTaggedValue(2).GetRawData());
834
835 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(2.2));
836 JSTaggedValue tagged2 =
837 JSTaggedValue(JSHandle<JSPrimitiveRef>::Cast(JSTaggedValue::ToObject(thread, value2))->GetValue(thread));
838 EXPECT_EQ(tagged2.GetRawData(), JSTaggedValue(static_cast<double>(2.2)).GetRawData());
839
840 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue::True());
841 JSTaggedValue tagged3 =
842 JSTaggedValue(JSHandle<JSPrimitiveRef>::Cast(JSTaggedValue::ToObject(thread, value3))->GetValue(thread));
843 EXPECT_EQ(tagged3.GetRawData(), JSTaggedValue::True().GetRawData());
844
845 JSHandle<JSTaggedValue> value4(factory->NewFromASCII("aaa"));
846 JSTaggedValue tagged4 =
847 JSTaggedValue(JSHandle<JSPrimitiveRef>::Cast(JSTaggedValue::ToObject(thread, value4))->GetValue(thread));
848 EXPECT_TRUE(tagged4.IsString());
849 EXPECT_EQ(EcmaStringAccessor::Compare(instance,
850 JSHandle<EcmaString>(thread, tagged4), JSHandle<EcmaString>(value4)), 0);
851
852 JSHandle<JSSymbol> symbol = factory->NewPublicSymbolWithChar("bbb");
853 JSHandle<EcmaString> str = factory->NewFromASCII("bbb");
854 JSHandle<JSTaggedValue> value5(symbol);
855 JSTaggedValue tagged5 =
856 JSTaggedValue(JSHandle<JSPrimitiveRef>::Cast(JSTaggedValue::ToObject(thread, value5))->GetValue(thread));
857 EXPECT_EQ(EcmaStringAccessor::Compare(instance, JSHandle<EcmaString>(thread,
858 EcmaString::Cast(reinterpret_cast<JSSymbol *>(tagged5.GetRawData())->GetDescription(thread))), str),
859 0);
860 EXPECT_TRUE(tagged5.IsSymbol());
861
862 EcmaVM *ecma = thread->GetEcmaVM();
863 JSHandle<JSTaggedValue> objectFun = ecma->GetGlobalEnv()->GetObjectFunction();
864 JSHandle<JSObject> jsObj = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objectFun), objectFun);
865 JSHandle<JSTaggedValue> value(jsObj);
866 EXPECT_EQ(*JSTaggedValue::ToObject(thread, value), *jsObj);
867 }
868
HWTEST_F_L0(JSTaggedValueTest,ToLength)869 HWTEST_F_L0(JSTaggedValueTest, ToLength)
870 {
871 JSTaggedNumber result;
872
873 JSTaggedValue intV(100);
874 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, intV));
875 EXPECT_EQ(result.GetNumber(), 100);
876
877 JSTaggedValue intV2(-1);
878 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, intV2));
879 EXPECT_EQ(result.GetNumber(), 0);
880
881 JSTaggedValue doubleV1((double)100.0);
882 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, doubleV1));
883 EXPECT_EQ(result.GetNumber(), (double)100.0);
884
885 JSTaggedValue doubleV2((double)100.123);
886 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, doubleV2));
887 EXPECT_EQ(result.GetNumber(), (double)100);
888
889 JSTaggedValue doubleV3((double)-1.0);
890 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, doubleV3));
891 EXPECT_EQ(result.GetNumber(), (double)0);
892
893 JSTaggedValue doubleV4((double)9007199254740992);
894 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, doubleV4));
895 EXPECT_EQ(result.GetNumber(), (double)9007199254740991);
896
897 JSTaggedValue undefinedV = JSTaggedValue::Undefined();
898 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, undefinedV));
899 EXPECT_EQ(result.GetNumber(), 0);
900
901 JSTaggedValue holeV = JSTaggedValue::Hole();
902 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, holeV));
903 EXPECT_EQ(result.GetNumber(), 0);
904
905 JSTaggedValue nullV = JSTaggedValue::Null();
906 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, nullV));
907 EXPECT_EQ(result.GetNumber(), 0);
908
909 JSTaggedValue falseV = JSTaggedValue::False();
910 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, falseV));
911 EXPECT_EQ(result.GetNumber(), 0);
912
913 JSTaggedValue trueV = JSTaggedValue::True();
914 result = JSTaggedValue::ToLength(thread, JSHandle<JSTaggedValue>(thread, trueV));
915 EXPECT_EQ(result.GetNumber(), 1);
916 }
917
HWTEST_F_L0(JSTaggedValueTest,IsArray)918 HWTEST_F_L0(JSTaggedValueTest, IsArray)
919 {
920 EcmaVM *ecma = thread->GetEcmaVM();
921 JSHandle<JSTaggedValue> objectFun = ecma->GetGlobalEnv()->GetArrayFunction();
922
923 JSHandle<JSObject> jsObj =
924 thread->GetEcmaVM()->GetFactory()->NewJSObjectByConstructor(JSHandle<JSFunction>(objectFun), objectFun);
925
926 ASSERT_TRUE(jsObj->IsJSArray());
927 ASSERT_FALSE(JSTaggedValue(1).IsArray(thread));
928
929 ASSERT_FALSE(
930 thread->GetEcmaVM()->GetFactory()->NewFromASCII("test").GetTaggedValue().IsArray(thread));
931 }
932
HWTEST_F_L0(JSTaggedValueTest,IsCallable_IsConstructor_IsExtensible)933 HWTEST_F_L0(JSTaggedValueTest, IsCallable_IsConstructor_IsExtensible)
934 {
935 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
936 JSHandle<JSFunction> jsFunction = thread->GetEcmaVM()->GetFactory()->NewJSFunction(env);
937 JSHClass *jsHclass = jsFunction->GetJSHClass();
938 jsHclass->SetCallable(true);
939 ASSERT_TRUE(jsFunction->IsCallable());
940 jsHclass->SetCallable(false);
941 ASSERT_FALSE(jsFunction->IsCallable());
942 jsHclass->SetConstructor(true);
943 ASSERT_TRUE(jsFunction->IsConstructor());
944 jsHclass->SetConstructor(false);
945 ASSERT_FALSE(jsFunction->IsConstructor());
946 jsHclass->SetExtensible(true);
947 ASSERT_TRUE(jsFunction->IsExtensible());
948 jsHclass->SetExtensible(false);
949 ASSERT_FALSE(jsFunction->IsExtensible());
950 ASSERT_FALSE(JSTaggedValue(1).IsExtensible(thread));
951 ASSERT_FALSE(JSTaggedValue(1).IsConstructor());
952 ASSERT_FALSE(JSTaggedValue(1).IsCallable());
953 }
954
HWTEST_F_L0(JSTaggedValueTest,IsInteger)955 HWTEST_F_L0(JSTaggedValueTest, IsInteger)
956 {
957 ASSERT_TRUE(JSTaggedValue(1).IsInteger());
958 ASSERT_TRUE(JSTaggedValue(1.0).IsInteger());
959 ASSERT_TRUE(JSTaggedValue(-1.0).IsInteger());
960 ASSERT_FALSE(JSTaggedValue(-1.1).IsInteger());
961 ASSERT_FALSE(JSTaggedValue(1.1).IsInteger());
962 ASSERT_FALSE(JSTaggedValue(std::numeric_limits<double>::infinity()).IsInteger());
963 ASSERT_FALSE(JSTaggedValue((-1) * std::numeric_limits<double>::infinity()).IsInteger());
964 ASSERT_TRUE(JSTaggedValue(0).IsInteger());
965 ASSERT_TRUE(JSTaggedValue(0.0).IsInteger());
966 ASSERT_FALSE(JSTaggedValue::True().IsInteger());
967 ASSERT_FALSE(JSTaggedValue::Undefined().IsInteger());
968 ASSERT_FALSE(JSTaggedValue::Null().IsInteger());
969 ASSERT_FALSE(JSTaggedValue::False().IsInteger());
970 ASSERT_FALSE(JSTaggedValue::Hole().IsInteger());
971 ASSERT_FALSE(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test").GetTaggedValue().IsInteger());
972 }
973
HWTEST_F_L0(JSTaggedValueTest,IsPropertyKey)974 HWTEST_F_L0(JSTaggedValueTest, IsPropertyKey)
975 {
976 ASSERT_TRUE(JSTaggedValue::IsPropertyKey(
977 JSHandle<JSTaggedValue>(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test"))));
978 }
979
HWTEST_F_L0(JSTaggedValueTest,IsRegExp)980 HWTEST_F_L0(JSTaggedValueTest, IsRegExp)
981 {
982 JSHandle<EcmaString> string = thread->GetEcmaVM()->GetFactory()->NewFromASCII("test");
983 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>::Cast(string);
984 ASSERT_FALSE(JSObject::IsRegExp(thread, obj));
985 }
986
HWTEST_F_L0(JSTaggedValueTest,IsOnlyJSObject)987 HWTEST_F_L0(JSTaggedValueTest, IsOnlyJSObject)
988 {
989 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
990
991 JSHandle<JSArray> array = factory->NewJSArray();
992 ASSERT_FALSE(array.GetTaggedValue().IsOnlyJSObject());
993 ASSERT_TRUE(array.GetTaggedValue().IsJSObject());
994
995 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
996 JSHandle<JSTaggedValue> objectFuncPrototype = env->GetObjectFunctionPrototype();
997 JSHandle<JSHClass> hclass = factory->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objectFuncPrototype);
998 JSHandle<JSObject> object = thread->GetEcmaVM()->GetFactory()->NewJSObject(hclass);
999 ASSERT_TRUE(object.GetTaggedValue().IsOnlyJSObject());
1000 ASSERT_TRUE(object.GetTaggedValue().IsJSObject());
1001 }
1002
HWTEST_F_L0(JSTaggedValueTest,SameValue)1003 HWTEST_F_L0(JSTaggedValueTest, SameValue)
1004 {
1005 EcmaVM *ecma = thread->GetEcmaVM();
1006 JSHandle<JSTaggedValue> objectFun = ecma->GetGlobalEnv()->GetObjectFunction();
1007
1008 JSHandle<JSObject> jsObj = ecma->GetFactory()->NewJSObjectByConstructor(JSHandle<JSFunction>(objectFun), objectFun);
1009
1010 // not same type
1011 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(1), JSTaggedValue::False()));
1012 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(1.0), JSTaggedValue::True()));
1013 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(1),
1014 ecma->GetFactory()->NewFromASCII("test").GetTaggedValue()));
1015 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(1), JSTaggedValue(*jsObj)));
1016 JSHandle<JSTaggedValue> test(ecma->GetFactory()->NewFromASCII("test"));
1017 ASSERT_FALSE(JSTaggedValue::SameValue(thread, test.GetTaggedValue(), JSTaggedValue(*jsObj)));
1018
1019 // number compare
1020 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue(1), JSTaggedValue(1)));
1021 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue(1), JSTaggedValue(1.0)));
1022 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(1.0), JSTaggedValue(2.0)));
1023 ASSERT_FALSE(JSTaggedValue::SameValue(thread,
1024 JSTaggedValue(std::numeric_limits<int>::quiet_NaN()), JSTaggedValue(2.0)));
1025 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue(std::numeric_limits<int>::quiet_NaN()),
1026 JSTaggedValue(std::numeric_limits<int>::quiet_NaN())));
1027 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue(std::numeric_limits<double>::quiet_NaN()),
1028 JSTaggedValue(std::numeric_limits<double>::quiet_NaN())));
1029 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(0.0), JSTaggedValue(-0.0)));
1030 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue(0), JSTaggedValue(-0)));
1031 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue(1.0), JSTaggedValue(-1.0)));
1032
1033 // string compare
1034 JSHandle<JSTaggedValue> test1(ecma->GetFactory()->NewFromASCII("test1"));
1035 ASSERT_FALSE(JSTaggedValue::SameValue(thread, test.GetTaggedValue(), test1.GetTaggedValue()));
1036 ASSERT_TRUE(JSTaggedValue::SameValue(thread, test.GetTaggedValue(), test.GetTaggedValue()));
1037
1038 // bool compare
1039 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue::True(), JSTaggedValue::True()));
1040 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue::False(), JSTaggedValue::False()));
1041 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue::False(), JSTaggedValue::True()));
1042 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue::True(), JSTaggedValue::False()));
1043
1044 // js object compare
1045 ASSERT_TRUE(JSTaggedValue::SameValue(thread, jsObj.GetTaggedValue(), jsObj.GetTaggedValue()));
1046
1047 // undefined or null compare
1048 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue::Undefined(), JSTaggedValue::Undefined()));
1049 ASSERT_TRUE(JSTaggedValue::SameValue(thread, JSTaggedValue::Null(), JSTaggedValue::Null()));
1050 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue::Undefined(), JSTaggedValue::Null()));
1051 ASSERT_FALSE(JSTaggedValue::SameValue(thread, JSTaggedValue::Null(), JSTaggedValue::Undefined()));
1052 }
1053
HWTEST_F_L0(JSTaggedValueTest,SameValueZero)1054 HWTEST_F_L0(JSTaggedValueTest, SameValueZero)
1055 {
1056 // SameValueZero differs from SameValue only in its treatment of +0 and -0.
1057 ASSERT_TRUE(JSTaggedValue::SameValueZero(thread, JSTaggedValue(0.0), JSTaggedValue(-0.0)));
1058 }
1059
HWTEST_F_L0(JSTaggedValueTest,Less)1060 HWTEST_F_L0(JSTaggedValueTest, Less)
1061 {
1062 JSHandle<JSTaggedValue> test(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test"));
1063 JSHandle<JSTaggedValue> test1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test1"));
1064 JSHandle<JSTaggedValue> test2(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test2"));
1065
1066 ASSERT_TRUE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0)),
1067 JSHandle<JSTaggedValue>(thread, JSTaggedValue(2.0))));
1068 ASSERT_FALSE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)),
1069 JSHandle<JSTaggedValue>(thread, JSTaggedValue(-0.0))));
1070 ASSERT_TRUE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)),
1071 JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))));
1072
1073 ASSERT_TRUE(JSTaggedValue::Less(thread, test, test1));
1074 ASSERT_FALSE(JSTaggedValue::Less(thread, test2, test1));
1075 ASSERT_FALSE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), test1));
1076 ASSERT_FALSE(JSTaggedValue::Less(thread, test2, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))));
1077
1078 ASSERT_TRUE(JSTaggedValue::Less(
1079 thread, JSHandle<JSTaggedValue>(thread->GetEcmaVM()->GetFactory()->NewFromASCII("1")),
1080 JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))));
1081 ASSERT_TRUE(JSTaggedValue::Less(
1082 thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)),
1083 JSHandle<JSTaggedValue>(thread->GetEcmaVM()->GetFactory()->NewFromASCII("2"))));
1084
1085 ASSERT_TRUE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1086 JSHandle<JSTaggedValue>(thread, JSTaggedValue::True())));
1087 ASSERT_FALSE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1088 JSHandle<JSTaggedValue>(thread, JSTaggedValue::False())));
1089 ASSERT_FALSE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined()),
1090 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null())));
1091 ASSERT_FALSE(JSTaggedValue::Less(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1092 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined())));
1093 }
1094
HWTEST_F_L0(JSTaggedValueTest,Equal)1095 HWTEST_F_L0(JSTaggedValueTest, Equal)
1096 {
1097 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined()),
1098 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined())));
1099 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1100 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined())));
1101 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1102 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null())));
1103 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1104 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined())));
1105 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1106 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))));
1107 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1108 JSHandle<JSTaggedValue>(thread, JSTaggedValue::True())));
1109 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null()),
1110 JSHandle<JSTaggedValue>(thread, JSTaggedValue::False())));
1111 }
1112
HWTEST_F_L0(JSTaggedValueTest,NumberEqual)1113 HWTEST_F_L0(JSTaggedValueTest, NumberEqual)
1114 {
1115 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)),
1116 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))));
1117 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)),
1118 JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))));
1119 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0)),
1120 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0))));
1121 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)),
1122 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0))));
1123 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)),
1124 JSHandle<JSTaggedValue>(thread, JSTaggedValue(-0.0))));
1125 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)),
1126 JSHandle<JSTaggedValue>(thread, JSTaggedValue(-0))));
1127 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)),
1128 JSHandle<JSTaggedValue>(thread, JSTaggedValue::True())));
1129 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)),
1130 JSHandle<JSTaggedValue>(thread, JSTaggedValue::False())));
1131 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)),
1132 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined())));
1133 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)),
1134 JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null())));
1135 }
1136
HWTEST_F_L0(JSTaggedValueTest,StringEqual)1137 HWTEST_F_L0(JSTaggedValueTest, StringEqual)
1138 {
1139 JSHandle<JSTaggedValue> test(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test"));
1140 JSHandle<JSTaggedValue> test1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test1"));
1141 JSHandle<JSTaggedValue> empty(thread->GetEcmaVM()->GetFactory()->NewFromASCII(""));
1142 JSHandle<JSTaggedValue> char0(thread->GetEcmaVM()->GetFactory()->NewFromASCII("0"));
1143 JSHandle<JSTaggedValue> char1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("1"));
1144 JSHandle<JSTaggedValue> charM1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("-1"));
1145 JSHandle<JSTaggedValue> charM0Point0(thread->GetEcmaVM()->GetFactory()->NewFromASCII("-0.0"));
1146 JSHandle<JSTaggedValue> charM0Point1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("-0.1"));
1147
1148 ASSERT_TRUE(JSTaggedValue::Equal(thread, test, test));
1149 ASSERT_FALSE(JSTaggedValue::Equal(thread, test, test1));
1150 ASSERT_FALSE(JSTaggedValue::Equal(thread, test, empty));
1151 ASSERT_TRUE(JSTaggedValue::Equal(thread, empty, empty));
1152
1153 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)), char0));
1154 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)), char0));
1155 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0)), char1));
1156 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(-1.0)), charM1));
1157 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)), charM0Point0));
1158 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)), charM0Point1));
1159
1160 ASSERT_TRUE(JSTaggedValue::Equal(thread, char1, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))));
1161 ASSERT_TRUE(JSTaggedValue::Equal(thread, char1, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True())));
1162 ASSERT_TRUE(JSTaggedValue::Equal(thread, char0, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False())));
1163 ASSERT_FALSE(JSTaggedValue::Equal(thread, char0, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined())));
1164 ASSERT_FALSE(JSTaggedValue::Equal(thread, char0, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Null())));
1165 }
1166
HWTEST_F_L0(JSTaggedValueTest,BooleanEqual)1167 HWTEST_F_L0(JSTaggedValueTest, BooleanEqual)
1168 {
1169 JSHandle<JSTaggedValue> char0(thread->GetEcmaVM()->GetFactory()->NewFromASCII("0"));
1170 JSHandle<JSTaggedValue> char0Point0(thread->GetEcmaVM()->GetFactory()->NewFromASCII("0.0"));
1171 JSHandle<JSTaggedValue> char1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("1"));
1172 JSHandle<JSTaggedValue> char1Point0(thread->GetEcmaVM()->GetFactory()->NewFromASCII("1.0"));
1173 JSHandle<JSTaggedValue> charM1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("-1"));
1174 JSHandle<JSTaggedValue> charM0Point0(thread->GetEcmaVM()->GetFactory()->NewFromASCII("-0.0"));
1175 JSHandle<JSTaggedValue> charM0Point1(thread->GetEcmaVM()->GetFactory()->NewFromASCII("-0.1"));
1176
1177 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1178 JSHandle<JSTaggedValue>(thread, JSTaggedValue::True())));
1179 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1180 JSHandle<JSTaggedValue>(thread, JSTaggedValue::False())));
1181 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1182 JSHandle<JSTaggedValue>(thread, JSTaggedValue::False())));
1183 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1184 JSHandle<JSTaggedValue>(thread, JSTaggedValue::True())));
1185 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1186 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))));
1187 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1188 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0))));
1189 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1190 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1191 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()),
1192 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0))));
1193 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1194 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1195 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1196 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0))));
1197 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1198 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))));
1199 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()),
1200 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0))));
1201 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()), char0));
1202 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()), char0Point0));
1203 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()), char1));
1204 ASSERT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()), char1Point0));
1205 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::True()), char0));
1206 ASSERT_FALSE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::False()), char1));
1207 }
1208
HWTEST_F_L0(JSTaggedValueTest,SymbolEqual)1209 HWTEST_F_L0(JSTaggedValueTest, SymbolEqual)
1210 {
1211 JSHandle<JSTaggedValue> test(thread->GetEcmaVM()->GetFactory()->NewFromASCII("test"));
1212 JSHandle<JSTaggedValue> testSymbol(thread->GetEcmaVM()->GetFactory()->NewPublicSymbolWithChar("test"));
1213 ASSERT_FALSE(JSTaggedValue::Equal(thread, testSymbol, test));
1214 }
1215
HWTEST_F_L0(JSTaggedValueTest,StrictEqual)1216 HWTEST_F_L0(JSTaggedValueTest, StrictEqual)
1217 {
1218 // This algorithm differs from the SameValue Algorithm in its treatment of signed zeroes and NaNs.
1219 ASSERT_TRUE(JSTaggedValue::StrictEqual(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0.0)),
1220 JSHandle<JSTaggedValue>(thread, JSTaggedValue(-0.0))));
1221 ASSERT_FALSE(JSTaggedValue::StrictEqual(
1222 thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(std::numeric_limits<double>::quiet_NaN())),
1223 JSHandle<JSTaggedValue>(thread, JSTaggedValue(std::numeric_limits<double>::quiet_NaN()))));
1224 ASSERT_FALSE(JSTaggedValue::StrictEqual(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)),
1225 JSHandle<JSTaggedValue>(thread, JSTaggedValue(2))));
1226 ASSERT_FALSE(JSTaggedValue::StrictEqual(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0)),
1227 JSHandle<JSTaggedValue>(thread, JSTaggedValue(2.0))));
1228 ASSERT_TRUE(JSTaggedValue::StrictEqual(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1.0)),
1229 JSHandle<JSTaggedValue>(thread, JSTaggedValue(1))));
1230 }
1231
HWTEST_F_L0(JSTaggedValueTest,EqualHeapObject0)1232 HWTEST_F_L0(JSTaggedValueTest, EqualHeapObject0)
1233 {
1234 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1235
1236 // 1. create a heapobject which is not ecmaobject
1237 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1238
1239 // 2. create a number
1240 JSHandle<JSTaggedValue> testNumber = JSHandle<JSTaggedValue>(thread, JSTaggedValue(TEST_NUMBER));
1241
1242 // 3. compare heapobject not ecmaobject with number
1243 bool res = JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()), testNumber);
1244 EXPECT_FALSE(res);
1245 }
1246
HWTEST_F_L0(JSTaggedValueTest,EqualHeapObject1)1247 HWTEST_F_L0(JSTaggedValueTest, EqualHeapObject1)
1248 {
1249 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1250
1251 // 1. create a heapobject which is not ecmaobject
1252 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1253
1254 // 2. create a boolean
1255 JSHandle<JSTaggedValue> testBoolean = JSHandle<JSTaggedValue>(thread, JSTaggedValue::True());
1256
1257 // 3. compare heapobject not ecmaobject with boolean
1258 bool res = JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()), testBoolean);
1259 ASSERT_FALSE(res);
1260 }
1261
HWTEST_F_L0(JSTaggedValueTest,EqualHeapObject2)1262 HWTEST_F_L0(JSTaggedValueTest, EqualHeapObject2)
1263 {
1264 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1265
1266 // 1. create a heapobject which is not ecmaobject
1267 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1268
1269 // 2. create a string
1270 JSHandle<JSTaggedValue> testString = JSHandle<JSTaggedValue>(factory->NewFromASCII(TEST_STRING.c_str()));
1271
1272 // 3. compare heapobject not ecmaobject with string
1273 bool res = JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()), testString);
1274 EXPECT_FALSE(res);
1275 }
1276
HWTEST_F_L0(JSTaggedValueTest,EqualHeapObject3)1277 HWTEST_F_L0(JSTaggedValueTest, EqualHeapObject3)
1278 {
1279 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1280
1281 // 1. create a heapobject which is not ecmaobject
1282 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1283
1284 // 2. create a symbol
1285 JSHandle<JSTaggedValue> testSymbol = JSHandle<JSTaggedValue>(factory->NewJSSymbol());
1286
1287 // 3. compare heapobject not ecmaobject with symbol
1288 bool res = JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()), testSymbol);
1289 EXPECT_FALSE(res);
1290 }
1291
HWTEST_F_L0(JSTaggedValueTest,EqualHeapObject4)1292 HWTEST_F_L0(JSTaggedValueTest, EqualHeapObject4)
1293 {
1294 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1295
1296 // 1. create a heapobject which is not ecmaobject
1297 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1298
1299 // 2. create a bigint
1300 JSHandle<JSTaggedValue> testBigInt = JSHandle<JSTaggedValue>(factory->NewBigInt<>(TEST_NUMBER));
1301
1302 // 3. compare heapobject not ecmaobject with bigint
1303 bool res = JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()), testBigInt);
1304 EXPECT_FALSE(res);
1305 }
1306
HWTEST_F_L0(JSTaggedValueTest,EqualNumber0)1307 HWTEST_F_L0(JSTaggedValueTest, EqualNumber0)
1308 {
1309 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1310
1311 // 1. create a number
1312 JSHandle<JSTaggedValue> testNumber = JSHandle<JSTaggedValue>(thread, JSTaggedValue(TEST_NUMBER));
1313
1314 // 2. create a heapobject which is not ecmaobject
1315 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1316
1317 // 3. compare heapobject not ecmaobject with number
1318 bool res = JSTaggedValue::Equal(thread, testNumber, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()));
1319 EXPECT_FALSE(res);
1320 }
1321
HWTEST_F_L0(JSTaggedValueTest,EqualString0)1322 HWTEST_F_L0(JSTaggedValueTest, EqualString0)
1323 {
1324 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1325
1326 // 1. create a string
1327 JSHandle<JSTaggedValue> testString = JSHandle<JSTaggedValue>(factory->NewFromASCII(TEST_STRING.c_str()));
1328
1329 // 2. create a heapobject which is not ecmaobject
1330 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1331
1332 // 3. compare heapobject not ecmaobject with number
1333 bool res = JSTaggedValue::Equal(thread, testString, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()));
1334 EXPECT_FALSE(res);
1335 }
1336
HWTEST_F_L0(JSTaggedValueTest,EqualSymbol0)1337 HWTEST_F_L0(JSTaggedValueTest, EqualSymbol0)
1338 {
1339 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1340
1341 // 1. create a symbol
1342 JSHandle<JSTaggedValue> testSymbol = JSHandle<JSTaggedValue>(factory->NewJSSymbol());
1343
1344 // 2. create a heapobject which is not ecmaobject
1345 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1346
1347 // 3. compare heapobject not ecmaobject with number
1348 bool res = JSTaggedValue::Equal(thread, testSymbol, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()));
1349 EXPECT_FALSE(res);
1350 }
1351
HWTEST_F_L0(JSTaggedValueTest,EqualBigInt0)1352 HWTEST_F_L0(JSTaggedValueTest, EqualBigInt0)
1353 {
1354 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1355
1356 // 1. create a bigint
1357 JSHandle<JSTaggedValue> testBigInt = JSHandle<JSTaggedValue>(factory->NewBigInt<>(TEST_NUMBER));
1358
1359 // 2. create a heapobject which is not ecmaobject
1360 JSHandle<TaggedArray> array = factory->NewTaggedArray(TEST_TAGGED_ARRAY_LENGTH);
1361
1362 // 3. compare heapobject not ecmaobject with number
1363 bool res = JSTaggedValue::Equal(thread, testBigInt, JSHandle<JSTaggedValue>(thread, array.GetTaggedValue()));
1364 EXPECT_FALSE(res);
1365 }
1366 } // namespace panda::test
1367