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