1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/builtins/builtins_number.h"
17
18 #include <cmath>
19 #include <iostream>
20
21 #include "ecmascript/base/number_helper.h"
22 #include "ecmascript/base/string_helper.h"
23 #include "ecmascript/ecma_runtime_call_info.h"
24 #include "ecmascript/ecma_string.h"
25 #include "ecmascript/ecma_vm.h"
26 #include "ecmascript/global_env.h"
27 #include "ecmascript/js_function.h"
28 #include "ecmascript/js_global_object.h"
29 #include "ecmascript/js_handle.h"
30 #include "ecmascript/js_primitive_ref.h"
31 #include "ecmascript/js_tagged_value-inl.h"
32 #include "ecmascript/js_thread.h"
33 #include "ecmascript/object_factory.h"
34 #include "ecmascript/tests/test_helper.h"
35
36 using namespace panda::ecmascript;
37 using namespace panda::ecmascript::builtins;
38
39 namespace panda::test {
40 class BuiltinsNumberTest : public testing::Test {
41 public:
SetUpTestCase()42 static void SetUpTestCase()
43 {
44 GTEST_LOG_(INFO) << "SetUpTestCase";
45 }
46
TearDownTestCase()47 static void TearDownTestCase()
48 {
49 GTEST_LOG_(INFO) << "TearDownCase";
50 }
51
SetUp()52 void SetUp() override
53 {
54 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
55 }
56
TearDown()57 void TearDown() override
58 {
59 TestHelper::DestroyEcmaVMWithScope(instance, scope);
60 }
61
62 EcmaVM *instance {nullptr};
63 EcmaHandleScope *scope {nullptr};
64 JSThread *thread {nullptr};
65 };
66
67 // new Number(10)
HWTEST_F_L0(BuiltinsNumberTest,NumberConstructor)68 HWTEST_F_L0(BuiltinsNumberTest, NumberConstructor)
69 {
70 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
71
72 JSHandle<JSFunction> number(env->GetNumberFunction());
73 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
74
75 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*number), 6);
76 ecmaRuntimeCallInfo->SetFunction(number.GetTaggedValue());
77 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
78 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(5)));
79
80 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
81 JSTaggedValue result = BuiltinsNumber::NumberConstructor(ecmaRuntimeCallInfo);
82 TestHelper::TearDownFrame(thread, prev);
83 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
84 ASSERT_TRUE(value.IsECMAObject());
85 JSPrimitiveRef *ref = JSPrimitiveRef::Cast(value.GetTaggedObject());
86 ASSERT_EQ(ref->GetValue().GetDouble(), 5.0);
87 }
88
89 // Number.isFinite(-10)
HWTEST_F_L0(BuiltinsNumberTest,IsFinite)90 HWTEST_F_L0(BuiltinsNumberTest, IsFinite)
91 {
92 const double value = -10;
93 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
94 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
95 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
96 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(value)));
97
98 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
99 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
100 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
101 TestHelper::TearDownFrame(thread, prev);
102 }
103
104 // Number.isFinite(Number.MAX_VALUE)
HWTEST_F_L0(BuiltinsNumberTest,IsFinite1)105 HWTEST_F_L0(BuiltinsNumberTest, IsFinite1)
106 {
107 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
108 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
109 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
110 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::MAX_VALUE));
111
112 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
113 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
114 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
115 TestHelper::TearDownFrame(thread, prev);
116 }
117
118 // Number.isFinite("helloworld")
HWTEST_F_L0(BuiltinsNumberTest,IsFinite2)119 HWTEST_F_L0(BuiltinsNumberTest, IsFinite2)
120 {
121 JSHandle<EcmaString> test = thread->GetEcmaVM()->GetFactory()->NewFromASCII("helloworld");
122 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
123 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
124 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
125 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
126
127 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
128 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
129 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
130 TestHelper::TearDownFrame(thread, prev);
131 }
132
133 // Number.isFinite(NaN)
HWTEST_F_L0(BuiltinsNumberTest,IsFinite3)134 HWTEST_F_L0(BuiltinsNumberTest, IsFinite3)
135 {
136 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
137 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
138 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
139 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::NAN_VALUE));
140
141 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
142 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
143 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
144 TestHelper::TearDownFrame(thread, prev);
145 }
146
147 // Number.isFinite(Infinity)
HWTEST_F_L0(BuiltinsNumberTest,IsFinite4)148 HWTEST_F_L0(BuiltinsNumberTest, IsFinite4)
149 {
150 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
151 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
152 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
153 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
154
155 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
156 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
157 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
158 TestHelper::TearDownFrame(thread, prev);
159 }
160
161 // Number.isFinite(undefined)
HWTEST_F_L0(BuiltinsNumberTest,IsFinite5)162 HWTEST_F_L0(BuiltinsNumberTest, IsFinite5)
163 {
164 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
165 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
166 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
167 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
168
169 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
170 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
171 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
172 TestHelper::TearDownFrame(thread, prev);
173 }
174
175 // Number.isFinite(null)
HWTEST_F_L0(BuiltinsNumberTest,IsFinite6)176 HWTEST_F_L0(BuiltinsNumberTest, IsFinite6)
177 {
178 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
179 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
180 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
181 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
182
183 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
184 JSTaggedValue result = BuiltinsNumber::IsFinite(ecmaRuntimeCallInfo);
185 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
186 TestHelper::TearDownFrame(thread, prev);
187 }
188
189 // Number.isInteger(0.1)
HWTEST_F_L0(BuiltinsNumberTest,IsInteger)190 HWTEST_F_L0(BuiltinsNumberTest, IsInteger)
191 {
192 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
193 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
194 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
195 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(0.1));
196
197 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
198 JSTaggedValue result = BuiltinsNumber::IsInteger(ecmaRuntimeCallInfo);
199 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
200 TestHelper::TearDownFrame(thread, prev);
201 }
202
203 // Number.isNaN(0.1)
HWTEST_F_L0(BuiltinsNumberTest,IsNaN)204 HWTEST_F_L0(BuiltinsNumberTest, IsNaN)
205 {
206 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
207 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
208 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
209 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(0.1));
210
211 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
212 JSTaggedValue result = BuiltinsNumber::IsNaN(ecmaRuntimeCallInfo);
213 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
214 TestHelper::TearDownFrame(thread, prev);
215 }
216
HWTEST_F_L0(BuiltinsNumberTest,ToString1)217 HWTEST_F_L0(BuiltinsNumberTest, ToString1)
218 {
219 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
220 auto ecmaVM = thread->GetEcmaVM();
221 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
222
223 // new Number(123.456).toString(7)
224 JSHandle<JSFunction> numberObject(env->GetNumberFunction());
225 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(123.456));
226 JSHandle<JSPrimitiveRef> number = thread->GetEcmaVM()->GetFactory()->NewJSPrimitiveRef(numberObject, value);
227
228 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
229 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
230 ecmaRuntimeCallInfo1->SetThis(number.GetTaggedValue());
231 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(7.0));
232
233 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
234 JSTaggedValue result1 = BuiltinsNumber::ToString(ecmaRuntimeCallInfo1);
235 ASSERT_TRUE(result1.IsString());
236 JSHandle<EcmaString> res1(thread, reinterpret_cast<EcmaString *>(result1.GetRawData()));
237 JSHandle<EcmaString> correctResult1 = factory->NewFromASCII("234.312256641535441");
238 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res1, *correctResult1));
239 TestHelper::TearDownFrame(thread, prev);
240
241 // (15).toString(4)
242 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
243 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
244 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue(15));
245 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(4));
246
247 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
248 JSTaggedValue result2 = BuiltinsNumber::ToString(ecmaRuntimeCallInfo2);
249 ASSERT_TRUE(result2.IsString());
250 JSHandle<EcmaString> res2(thread, reinterpret_cast<EcmaString *>(result2.GetRawData()));
251 JSHandle<EcmaString> correctResult2 = factory->NewFromASCII("33");
252 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res2, *correctResult2));
253 TestHelper::TearDownFrame(thread, prev);
254
255 // (5).toString(8)
256 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
257 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
258 ecmaRuntimeCallInfo3->SetThis(JSTaggedValue(5));
259 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(8));
260
261 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
262 JSTaggedValue result3 = BuiltinsNumber::ToString(ecmaRuntimeCallInfo3);
263 ASSERT_TRUE(result3.IsString());
264 JSHandle<EcmaString> res3(thread, reinterpret_cast<EcmaString *>(result3.GetRawData()));
265 JSHandle<EcmaString> correctResult3 = factory->NewFromASCII("5");
266 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res3, *correctResult3));
267 TestHelper::TearDownFrame(thread, prev);
268
269 // (0).toString(8)
270 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
271 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
272 ecmaRuntimeCallInfo4->SetThis(JSTaggedValue(0));
273 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(8));
274
275 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
276 JSTaggedValue result4 = BuiltinsNumber::ToString(ecmaRuntimeCallInfo4);
277 ASSERT_TRUE(result4.IsString());
278 JSHandle<EcmaString> res4(thread, reinterpret_cast<EcmaString *>(result4.GetRawData()));
279 JSHandle<EcmaString> correctResult4 = factory->NewFromASCII("0");
280 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res4, *correctResult4));
281 TestHelper::TearDownFrame(thread, prev);
282 }
HWTEST_F_L0(BuiltinsNumberTest,ToString2)283 HWTEST_F_L0(BuiltinsNumberTest, ToString2)
284 {
285 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
286 // (-50).toString(35)
287 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
288 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
289 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(-50));
290 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(35));
291
292 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
293 JSTaggedValue result1 = BuiltinsNumber::ToString(ecmaRuntimeCallInfo1);
294 ASSERT_TRUE(result1.IsString());
295 JSHandle<EcmaString> res1(thread, reinterpret_cast<EcmaString *>(result1.GetRawData()));
296 JSHandle<EcmaString> correctResult1 = factory->NewFromASCII("-1f");
297 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res1, *correctResult1));
298 TestHelper::TearDownFrame(thread, prev);
299
300 // (2).toString(2.5)
301 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
302 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
303 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue(2));
304 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(2.5));
305
306 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
307 JSTaggedValue result2 = BuiltinsNumber::ToString(ecmaRuntimeCallInfo2);
308 ASSERT_TRUE(result2.IsString());
309 JSHandle<EcmaString> res2(thread, reinterpret_cast<EcmaString *>(result2.GetRawData()));
310 JSHandle<EcmaString> correctResult2 = factory->NewFromASCII("10");
311 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res2, *correctResult2));
312 TestHelper::TearDownFrame(thread, prev);
313 }
314
315 // new Number(123.456).toExponential(5)
HWTEST_F_L0(BuiltinsNumberTest,IsExponential)316 HWTEST_F_L0(BuiltinsNumberTest, IsExponential)
317 {
318 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
319 auto ecmaVM = thread->GetEcmaVM();
320 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
321
322 JSHandle<JSFunction> numberObject(env->GetNumberFunction());
323 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(123.456));
324 JSHandle<JSPrimitiveRef> number = factory->NewJSPrimitiveRef(numberObject, value);
325
326 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
327 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
328 ecmaRuntimeCallInfo->SetThis(number.GetTaggedValue());
329 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(5.0));
330
331 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
332 JSTaggedValue result = BuiltinsNumber::ToExponential(ecmaRuntimeCallInfo);
333 ASSERT_TRUE(result.IsString());
334 JSHandle<EcmaString> res(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
335 JSHandle<EcmaString> correctResult = factory->NewFromASCII("1.23456e+2");
336 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res, *correctResult));
337 TestHelper::TearDownFrame(thread, prev);
338 }
339
340 // new Number(123.456).toFixed(10)
HWTEST_F_L0(BuiltinsNumberTest,ToFixed)341 HWTEST_F_L0(BuiltinsNumberTest, ToFixed)
342 {
343 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
344 auto ecmaVM = thread->GetEcmaVM();
345 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
346
347 JSHandle<JSFunction> numberObject(env->GetNumberFunction());
348 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(123.456));
349 JSHandle<JSPrimitiveRef> number = factory->NewJSPrimitiveRef(numberObject, value);
350
351 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
352 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
353 ecmaRuntimeCallInfo->SetThis(number.GetTaggedValue());
354 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(10.0));
355
356 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
357 JSTaggedValue result = BuiltinsNumber::ToFixed(ecmaRuntimeCallInfo);
358 ASSERT_TRUE(result.IsString());
359 JSHandle<EcmaString> res(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
360 JSHandle<EcmaString> correctResult = factory->NewFromASCII("123.4560000000");
361 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res, *correctResult));
362 TestHelper::TearDownFrame(thread, prev);
363 }
364
365 // new Number(123.456).toFixed(30)
HWTEST_F_L0(BuiltinsNumberTest,ToFixed1)366 HWTEST_F_L0(BuiltinsNumberTest, ToFixed1)
367 {
368 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
369 auto ecmaVM = thread->GetEcmaVM();
370 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
371
372 JSHandle<JSFunction> numberObject(env->GetNumberFunction());
373 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(123.456));
374 JSHandle<JSPrimitiveRef> number = factory->NewJSPrimitiveRef(numberObject, value);
375
376 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
377 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
378 ecmaRuntimeCallInfo->SetThis(number.GetTaggedValue());
379 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(30.0));
380
381 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
382 JSTaggedValue result = BuiltinsNumber::ToFixed(ecmaRuntimeCallInfo);
383 ASSERT_TRUE(result.IsString());
384 JSHandle<EcmaString> res(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
385 JSHandle<EcmaString> correctResult = factory->NewFromASCII("123.456000000000003069544618483633");
386 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res, *correctResult));
387 TestHelper::TearDownFrame(thread, prev);
388 }
389
390 // new Number(1e21).toFixed(20)
HWTEST_F_L0(BuiltinsNumberTest,ToFixed2)391 HWTEST_F_L0(BuiltinsNumberTest, ToFixed2) {
392 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
393 auto ecmaVM = thread->GetEcmaVM();
394 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
395
396 JSHandle<JSFunction> numberObject(env->GetNumberFunction());
397 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1e21));
398 JSHandle<JSPrimitiveRef> number = factory->NewJSPrimitiveRef(numberObject, value);
399
400 auto ecmaRuntimeCallInfo =
401 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
402 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
403 ecmaRuntimeCallInfo->SetThis(number.GetTaggedValue());
404 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(20.0));
405
406 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
407 JSTaggedValue result = BuiltinsNumber::ToFixed(ecmaRuntimeCallInfo);
408 ASSERT_TRUE(result.IsString());
409 JSHandle<EcmaString> res(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
410 JSHandle<EcmaString> correctResult = factory->NewFromASCII("1e+21");
411 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res, *correctResult));
412 TestHelper::TearDownFrame(thread, prev);
413 }
414
415 // new Number(123.456).toPrecision(8)
HWTEST_F_L0(BuiltinsNumberTest,ToPrecision)416 HWTEST_F_L0(BuiltinsNumberTest, ToPrecision)
417 {
418 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
419 auto ecmaVM = thread->GetEcmaVM();
420 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
421
422 JSHandle<JSFunction> numberObject(env->GetNumberFunction());
423 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(123.456));
424 JSHandle<JSPrimitiveRef> number = factory->NewJSPrimitiveRef(numberObject, value);
425
426 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
427 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
428 ecmaRuntimeCallInfo->SetThis(number.GetTaggedValue());
429 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(8.0));
430
431 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
432 JSTaggedValue result = BuiltinsNumber::ToPrecision(ecmaRuntimeCallInfo);
433 ASSERT_TRUE(result.IsString());
434 JSHandle<EcmaString> res(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
435 JSHandle<EcmaString> correctResult = factory->NewFromASCII("123.45600");
436 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*res, *correctResult));
437 TestHelper::TearDownFrame(thread, prev);
438 }
439
440 // Number.parseFloat(0x123)
HWTEST_F_L0(BuiltinsNumberTest,parseFloat)441 HWTEST_F_L0(BuiltinsNumberTest, parseFloat)
442 {
443 JSHandle<EcmaString> param = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0x123");
444 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
445 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
446 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
447 ecmaRuntimeCallInfo->SetCallArg(0, param.GetTaggedValue());
448
449 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
450 JSTaggedValue result = BuiltinsNumber::ParseFloat(ecmaRuntimeCallInfo);
451 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(0)).GetRawData());
452 TestHelper::TearDownFrame(thread, prev);
453 }
454
455 // Number.parseFloat(0x123xx)
HWTEST_F_L0(BuiltinsNumberTest,parseFloat1)456 HWTEST_F_L0(BuiltinsNumberTest, parseFloat1)
457 {
458 JSHandle<EcmaString> param = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0x123xx");
459 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
460 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
461 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
462 ecmaRuntimeCallInfo->SetCallArg(0, param.GetTaggedValue());
463
464 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
465 JSTaggedValue result = BuiltinsNumber::ParseFloat(ecmaRuntimeCallInfo);
466 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(0)).GetRawData());
467 TestHelper::TearDownFrame(thread, prev);
468 }
469
470 // Number.parseInt(0x123)
HWTEST_F_L0(BuiltinsNumberTest,parseInt)471 HWTEST_F_L0(BuiltinsNumberTest, parseInt)
472 {
473 const char *number = "0x123";
474
475 JSHandle<EcmaString> param = thread->GetEcmaVM()->GetFactory()->NewFromASCII(number);
476 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
477 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
478 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
479 ecmaRuntimeCallInfo->SetCallArg(0, param.GetTaggedValue());
480 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(16.0));
481
482 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
483 JSTaggedValue result = BuiltinsNumber::ParseInt(ecmaRuntimeCallInfo);
484 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<int>(291)).GetRawData());
485 TestHelper::TearDownFrame(thread, prev);
486 }
487
488 // testcases of StringToDouble flags
HWTEST_F_L0(BuiltinsNumberTest,StringToDoubleFlags)489 HWTEST_F_L0(BuiltinsNumberTest, StringToDoubleFlags)
490 {
491 JSHandle<EcmaString> str;
492 Span<const uint8_t> sp;
493 CVector<uint8_t> buf;
494
495 // flags of IGNORE_TRAILING
496
497 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0a");
498 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
499 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 0);
500 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0b");
501 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
502 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 0);
503 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0o");
504 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
505 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 0);
506 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 00x");
507 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
508 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 0);
509 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 000.4_");
510 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
511 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 0.4);
512 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0010.s ");
513 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
514 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 10);
515 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0010e2");
516 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
517 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 1000);
518 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0010e+3_0");
519 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
520 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::IGNORE_TRAILING), 10000);
521
522 // flags of ALLOW_HEX
523 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0x");
524 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
525 ASSERT_TRUE(std::isnan(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_HEX)));
526 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0x10 ");
527 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
528 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_HEX), 16);
529 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0x1g");
530 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
531 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_HEX + base::IGNORE_TRAILING), 1);
532 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0xh");
533 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
534 ASSERT_TRUE(std::isnan(
535 base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_HEX + base::IGNORE_TRAILING)));
536
537 // flags of ALLOW_OCTAL
538 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0O");
539 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
540 ASSERT_TRUE(std::isnan(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_OCTAL)));
541 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0o10 ");
542 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
543 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_OCTAL), 8);
544 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0o1d");
545 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
546 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_OCTAL | base::IGNORE_TRAILING),
547 1);
548 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0o8");
549 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
550 ASSERT_TRUE(std::isnan(
551 base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_OCTAL | base::IGNORE_TRAILING)));
552
553 // flags of ALLOW_BINARY
554 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0b");
555 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
556 ASSERT_TRUE(std::isnan(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_BINARY)));
557 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0b10 ");
558 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
559 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_BINARY), 2);
560 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0b1d");
561 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
562 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_BINARY | base::IGNORE_TRAILING),
563 1);
564 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("0b2");
565 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
566 ASSERT_TRUE(std::isnan(
567 base::NumberHelper::StringToDouble(sp.begin(), sp.end(), 0, base::ALLOW_BINARY | base::IGNORE_TRAILING)));
568 }
569
570 // testcases of StringToDouble radix
HWTEST_F_L0(BuiltinsNumberTest,StringToDoubleRadix)571 HWTEST_F_L0(BuiltinsNumberTest, StringToDoubleRadix)
572 {
573 JSHandle<EcmaString> str;
574 Span<const uint8_t> sp;
575 CVector<uint8_t> buf;
576 int radix;
577
578 radix = 0; // default 10
579 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
580 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
581 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 100);
582 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100.3e2 ");
583 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
584 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 10030);
585 radix = 1;
586 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0000 ");
587 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
588 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 0);
589 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0001 ");
590 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
591 ASSERT_TRUE(std::isnan(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS)));
592 radix = 2;
593 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
594 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
595 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 4);
596 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 11 ");
597 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
598 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 3);
599 radix = 3;
600 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
601 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
602 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 9);
603 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 21 ");
604 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
605 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 7);
606 radix = 4;
607 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
608 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
609 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 16);
610 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 31 ");
611 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
612 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 13);
613 radix = 8;
614 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
615 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
616 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 64);
617 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 71 ");
618 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
619 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 57);
620 radix = 10;
621 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
622 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
623 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 100);
624 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 0020 ");
625 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
626 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 20);
627 radix = 16;
628 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
629 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
630 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 256);
631 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 1e ");
632 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
633 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 30);
634 radix = 18;
635 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
636 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
637 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 324);
638 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 1g ");
639 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
640 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 34);
641 radix = 25;
642 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
643 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
644 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 625);
645 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 1g ");
646 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
647 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 41);
648 radix = 36;
649 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 100 ");
650 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
651 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 1296);
652 str = thread->GetEcmaVM()->GetFactory()->NewFromASCII(" 1z ");
653 sp = EcmaStringAccessor(str).ToUtf8Span(buf);
654 ASSERT_EQ(base::NumberHelper::StringToDouble(sp.begin(), sp.end(), radix, base::NO_FLAGS), 71);
655 }
656
HWTEST_F_L0(BuiltinsNumberTest,NumberToString)657 HWTEST_F_L0(BuiltinsNumberTest, NumberToString)
658 {
659 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
660 JSHandle<EcmaString> res = factory->NewFromASCII("100");
661 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
662 base::NumberHelper::NumberToString(thread, JSTaggedValue(100)), res), 0);
663 res = factory->NewFromASCII("11223344");
664 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
665 base::NumberHelper::NumberToString(thread, JSTaggedValue(11223344)), res), 0);
666 res = factory->NewFromASCII("1234567890");
667 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
668 base::NumberHelper::NumberToString(thread, JSTaggedValue(1234567890)), res), 0);
669 res = factory->NewFromASCII("100");
670 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
671 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(100.0))), res), 0);
672 res = factory->NewFromASCII("100.5");
673 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
674 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(100.5))), res), 0);
675 res = factory->NewFromASCII("100.25");
676 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
677 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(100.25))), res), 0);
678 res = factory->NewFromASCII("100.125");
679 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
680 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(100.125))), res), 0);
681 res = factory->NewFromASCII("100.6125");
682 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
683 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(100.6125))), res), 0);
684 res = factory->NewFromASCII("0.0006125");
685 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
686 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(0.0006125))), res), 0);
687 res = factory->NewFromASCII("-0.0006125");
688 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
689 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(-0.0006125))), res), 0);
690 res = factory->NewFromASCII("-1234567890.0006125");
691 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
692 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(-1234567890.0006125))), res), 0);
693 res = factory->NewFromASCII("1234567890.0006125");
694 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
695 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(1234567890.0006125))), res), 0);
696 res = factory->NewFromASCII("11234567890.000612");
697 ASSERT_EQ(EcmaStringAccessor::Compare(instance,
698 base::NumberHelper::NumberToString(thread, JSTaggedValue(double(11234567890.0006125))), res), 0);
699 }
700 } // namespace panda::test
701