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