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