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_math.h"
17
18 #include "ecmascript/base/number_helper.h"
19 #include "ecmascript/ecma_runtime_call_info.h"
20 #include "ecmascript/ecma_vm.h"
21 #include "ecmascript/js_tagged_value-inl.h"
22 #include "ecmascript/js_tagged_value.h"
23 #include "ecmascript/js_thread.h"
24 #include "ecmascript/object_factory.h"
25 #include "ecmascript/tests/test_helper.h"
26
27 using namespace panda::ecmascript;
28 using namespace panda::ecmascript::builtins;
29 using namespace panda::ecmascript::base;
30
31 namespace panda::test {
32 class BuiltinsMathTest : public testing::Test {
33 public:
34 // Workaround: Avoid thread local leak [F/runtime: cannot create thread specific key for __cxa_get_globals()]
SetUpTestCase()35 static void SetUpTestCase()
36 {
37 TestHelper::CreateEcmaVMWithScope(instance_, thread_, scope_);
38 }
39
TearDownTestCase()40 static void TearDownTestCase()
41 {
42 TestHelper::DestroyEcmaVMWithScope(instance_, scope_);
43 }
44
45 static EcmaVM *instance_;
46 static EcmaHandleScope *scope_;
47 static JSThread *thread_;
48 };
49 EcmaVM *BuiltinsMathTest::instance_ = nullptr;
50 EcmaHandleScope *BuiltinsMathTest::scope_ = nullptr;
51 JSThread *BuiltinsMathTest::thread_ = nullptr;
52
53 // Math.abs(-10)
HWTEST_F_L0(BuiltinsMathTest,Abs)54 HWTEST_F_L0(BuiltinsMathTest, Abs)
55 {
56 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
57 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
58 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
59 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-10)));
60
61 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
62 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
63 TestHelper::TearDownFrame(thread_, prev);
64 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(10);
65 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
66 }
67
68 // Math.abs(10)
HWTEST_F_L0(BuiltinsMathTest,Abs_1)69 HWTEST_F_L0(BuiltinsMathTest, Abs_1)
70 {
71 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
72 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
73 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
74 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(10)));
75
76 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
77 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
78 TestHelper::TearDownFrame(thread_, prev);
79 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(10);
80 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
81 }
82
83 // Math.abs(0)
HWTEST_F_L0(BuiltinsMathTest,Abs_2)84 HWTEST_F_L0(BuiltinsMathTest, Abs_2)
85 {
86 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
87 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
88 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
89 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
90
91 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
92 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
93 TestHelper::TearDownFrame(thread_, prev);
94 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(0);
95 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
96 }
97
98 // Math.abs(null)
HWTEST_F_L0(BuiltinsMathTest,Abs_3)99 HWTEST_F_L0(BuiltinsMathTest, Abs_3)
100 {
101 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
102 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
103 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
104 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
105
106 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
107 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
108 TestHelper::TearDownFrame(thread_, prev);
109 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(0);
110 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
111 }
112
113 // Math.abs("hello")
HWTEST_F_L0(BuiltinsMathTest,Abs_4)114 HWTEST_F_L0(BuiltinsMathTest, Abs_4)
115 {
116 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("helloworld");
117
118 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
119 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
120 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
121 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
122
123 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
124 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
125 TestHelper::TearDownFrame(thread_, prev);
126 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
127 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
128 }
129
130 // Math.abs(Number.MAX_VALUE + 1)
HWTEST_F_L0(BuiltinsMathTest,Abs_5)131 HWTEST_F_L0(BuiltinsMathTest, Abs_5)
132 {
133 const double testValue = base::MAX_VALUE + 1;
134 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
135 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
136 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
137 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(testValue));
138
139 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
140 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
141 TestHelper::TearDownFrame(thread_, prev);
142 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::MAX_VALUE);
143 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
144 }
145
146 // Math.abs(Number.MIN_VALUE)
HWTEST_F_L0(BuiltinsMathTest,Abs_6)147 HWTEST_F_L0(BuiltinsMathTest, Abs_6)
148 {
149 const double testValue = base::MIN_VALUE + 1;
150 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
151 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
152 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
153 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(testValue));
154
155 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
156 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
157 TestHelper::TearDownFrame(thread_, prev);
158 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
159 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
160 }
161
162 // Math.abs(Number.POSITIVE_INFINITY + 1)
HWTEST_F_L0(BuiltinsMathTest,Abs_7)163 HWTEST_F_L0(BuiltinsMathTest, Abs_7)
164 {
165 const double testValue = base::POSITIVE_INFINITY + 1;
166 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
167 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
168 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
169 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(testValue));
170
171 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
172 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
173 TestHelper::TearDownFrame(thread_, prev);
174 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
175 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
176 }
177
178 // Math.abs(Number.NEGATIVE_INFINITY - 1)
HWTEST_F_L0(BuiltinsMathTest,Abs_8)179 HWTEST_F_L0(BuiltinsMathTest, Abs_8)
180 {
181 const double testValue = -base::POSITIVE_INFINITY - 1;
182 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
183 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
184 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
185 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(testValue));
186
187 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
188 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
189 TestHelper::TearDownFrame(thread_, prev);
190 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
191 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
192 }
193
194 // Math.abs(Number.NAN_VALUE)
HWTEST_F_L0(BuiltinsMathTest,Abs_9)195 HWTEST_F_L0(BuiltinsMathTest, Abs_9)
196 {
197 const double testValue = base::NAN_VALUE;
198 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
199 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
200 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
201 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(testValue));
202
203 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
204 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
205 TestHelper::TearDownFrame(thread_, prev);
206 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
207 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
208 }
209
210 // Math.abs(VALUE_UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Abs_10)211 HWTEST_F_L0(BuiltinsMathTest, Abs_10)
212 {
213 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
214 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
215 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
216 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
217
218 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
219 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
220 TestHelper::TearDownFrame(thread_, prev);
221 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
222 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
223 }
224
225 // Math.abs(true)
HWTEST_F_L0(BuiltinsMathTest,Abs_11)226 HWTEST_F_L0(BuiltinsMathTest, Abs_11)
227 {
228 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
229 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
230 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
231 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
232
233 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
234 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
235 TestHelper::TearDownFrame(thread_, prev);
236 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(1);
237 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
238 }
239
240 // Math.abs(false)
HWTEST_F_L0(BuiltinsMathTest,Abs_12)241 HWTEST_F_L0(BuiltinsMathTest, Abs_12)
242 {
243 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
244 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
245 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
246 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
247
248 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
249 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
250 TestHelper::TearDownFrame(thread_, prev);
251 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(0);
252 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
253 }
254
255 // Math.abs(hole)
HWTEST_F_L0(BuiltinsMathTest,Abs_13)256 HWTEST_F_L0(BuiltinsMathTest, Abs_13)
257 {
258 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
259 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
260 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
261 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Hole());
262
263 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
264 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
265 TestHelper::TearDownFrame(thread_, prev);
266 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
267 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
268 }
269
270 // Math.abs("100.12")
HWTEST_F_L0(BuiltinsMathTest,Abs_14)271 HWTEST_F_L0(BuiltinsMathTest, Abs_14)
272 {
273 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("100.12");
274 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
275 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
276 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
277 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
278
279 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
280 JSTaggedValue result = BuiltinsMath::Abs(ecmaRuntimeCallInfo);
281 TestHelper::TearDownFrame(thread_, prev);
282 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(100.12);
283 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
284 }
285
286 // Math.acos(-1)
HWTEST_F_L0(BuiltinsMathTest,Acos)287 HWTEST_F_L0(BuiltinsMathTest, Acos)
288 {
289 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
290 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
291 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
292 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
293
294 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
295 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
296 TestHelper::TearDownFrame(thread_, prev);
297 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(BuiltinsMath::PI);
298 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
299 }
300
301 // Math.acos(1)
HWTEST_F_L0(BuiltinsMathTest,Acos_1)302 HWTEST_F_L0(BuiltinsMathTest, Acos_1)
303 {
304 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
305 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
306 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
307 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
308
309 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
310 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
311 TestHelper::TearDownFrame(thread_, prev);
312 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
313 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
314 }
315
316 // Math.acos(-1.5)
HWTEST_F_L0(BuiltinsMathTest,Acos_2)317 HWTEST_F_L0(BuiltinsMathTest, Acos_2)
318 {
319 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
320 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
321 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
322 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-1.5));
323
324 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
325 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
326 TestHelper::TearDownFrame(thread_, prev);
327 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
328 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
329 }
330
331 // Math.acos(null)
HWTEST_F_L0(BuiltinsMathTest,Acos_3)332 HWTEST_F_L0(BuiltinsMathTest, Acos_3)
333 {
334 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
335 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
336 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
337 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
338
339 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
340 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
341 TestHelper::TearDownFrame(thread_, prev);
342 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
343 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
344 }
345
346 // Math.acos(UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Acos_4)347 HWTEST_F_L0(BuiltinsMathTest, Acos_4)
348 {
349 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
350 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
351 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
352 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
353
354 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
355 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
356 TestHelper::TearDownFrame(thread_, prev);
357 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
358 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
359 }
360
361 // Math.acos(true)
HWTEST_F_L0(BuiltinsMathTest,Acos_5)362 HWTEST_F_L0(BuiltinsMathTest, Acos_5)
363 {
364 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
365 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
366 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
367 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
368
369 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
370 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
371 TestHelper::TearDownFrame(thread_, prev);
372 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.0);
373 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
374 }
375
376 // Math.acos(false)
HWTEST_F_L0(BuiltinsMathTest,Acos_6)377 HWTEST_F_L0(BuiltinsMathTest, Acos_6)
378 {
379 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
380 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
381 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
382 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
383
384 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
385 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
386 TestHelper::TearDownFrame(thread_, prev);
387 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
388 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
389 }
390
391 // Math.acos("0.1")
HWTEST_F_L0(BuiltinsMathTest,Acos_7)392 HWTEST_F_L0(BuiltinsMathTest, Acos_7)
393 {
394 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.1");
395 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
396 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
397 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
398 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
399
400 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
401 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
402 TestHelper::TearDownFrame(thread_, prev);
403 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.4706289056333368);
404 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
405 }
406
407 // Math.acos("")
HWTEST_F_L0(BuiltinsMathTest,Acos_8)408 HWTEST_F_L0(BuiltinsMathTest, Acos_8)
409 {
410 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
411 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
412 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
413 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
414 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
415
416 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
417 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
418 TestHelper::TearDownFrame(thread_, prev);
419 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
420 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
421 }
422
423 // Math.acos(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Acos_9)424 HWTEST_F_L0(BuiltinsMathTest, Acos_9)
425 {
426 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
427 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
428 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
429 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
430
431 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
432 JSTaggedValue result = BuiltinsMath::Acos(ecmaRuntimeCallInfo);
433 TestHelper::TearDownFrame(thread_, prev);
434 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
435 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
436 }
437
438 // Math.acosh(1.1)
HWTEST_F_L0(BuiltinsMathTest,Acosh)439 HWTEST_F_L0(BuiltinsMathTest, Acosh)
440 {
441 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
442 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
443 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
444 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(1.1));
445
446 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
447 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
448 TestHelper::TearDownFrame(thread_, prev);
449 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.4435682543851154);
450 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
451 }
452
453 // Math.acosh(0.5)
HWTEST_F_L0(BuiltinsMathTest,Acosh_1)454 HWTEST_F_L0(BuiltinsMathTest, Acosh_1)
455 {
456 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
457 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
458 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
459 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(0.5));
460
461 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
462 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
463 TestHelper::TearDownFrame(thread_, prev);
464 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
465 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
466 }
467
468 // Math.acosh(base::POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Acosh_2)469 HWTEST_F_L0(BuiltinsMathTest, Acosh_2)
470 {
471 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
472 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
473 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
474 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
475
476 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
477 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
478 TestHelper::TearDownFrame(thread_, prev);
479 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
480 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
481 }
482
483 // Math.acosh(null)
HWTEST_F_L0(BuiltinsMathTest,Acosh_3)484 HWTEST_F_L0(BuiltinsMathTest, Acosh_3)
485 {
486 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
487 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
488 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
489 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
490
491 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
492 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
493 TestHelper::TearDownFrame(thread_, prev);
494 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
495 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
496 }
497
498 // Math.acosh(VALUE_UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Acosh_4)499 HWTEST_F_L0(BuiltinsMathTest, Acosh_4)
500 {
501 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
502 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
503 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
504 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
505
506 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
507 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
508 TestHelper::TearDownFrame(thread_, prev);
509 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
510 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
511 }
512
513 // Math.acosh(true)
HWTEST_F_L0(BuiltinsMathTest,Acosh_5)514 HWTEST_F_L0(BuiltinsMathTest, Acosh_5)
515 {
516 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
517 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
518 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
519 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
520
521 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
522 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
523 TestHelper::TearDownFrame(thread_, prev);
524 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.0);
525 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
526 }
527
528 // Math.acosh(false)
HWTEST_F_L0(BuiltinsMathTest,Acosh_6)529 HWTEST_F_L0(BuiltinsMathTest, Acosh_6)
530 {
531 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
532 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
533 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
534 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
535
536 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
537 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
538 TestHelper::TearDownFrame(thread_, prev);
539 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
540 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
541 }
542
543 // Math.acosh(hole)
HWTEST_F_L0(BuiltinsMathTest,Acosh_7)544 HWTEST_F_L0(BuiltinsMathTest, Acosh_7)
545 {
546 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
547 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
548 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
549 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Hole());
550
551 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
552 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
553 TestHelper::TearDownFrame(thread_, prev);
554 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
555 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
556 }
557
558 // Math.acosh("1")
HWTEST_F_L0(BuiltinsMathTest,Acosh_8)559 HWTEST_F_L0(BuiltinsMathTest, Acosh_8)
560 {
561 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("1");
562 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
563 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
564 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
565 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
566
567 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
568 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
569 TestHelper::TearDownFrame(thread_, prev);
570 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
571 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
572 }
573
574 // Math.acosh("")
HWTEST_F_L0(BuiltinsMathTest,Acosh_9)575 HWTEST_F_L0(BuiltinsMathTest, Acosh_9)
576 {
577 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
578 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
579 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
580 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
581 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
582
583 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
584 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
585 TestHelper::TearDownFrame(thread_, prev);
586 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
587 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
588 }
589
590 // Math.acosh(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Acosh_10)591 HWTEST_F_L0(BuiltinsMathTest, Acosh_10)
592 {
593 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
594 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
595 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
596 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
597
598 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
599 JSTaggedValue result = BuiltinsMath::Acosh(ecmaRuntimeCallInfo);
600 TestHelper::TearDownFrame(thread_, prev);
601 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
602 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
603 }
604
605 // Math.asin(-1)
HWTEST_F_L0(BuiltinsMathTest,Asin)606 HWTEST_F_L0(BuiltinsMathTest, Asin)
607 {
608 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
609 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
610 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
611 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
612
613 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
614 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
615 TestHelper::TearDownFrame(thread_, prev);
616 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.5707963267948966);
617 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
618 }
619
620 // Math.asin(1)
HWTEST_F_L0(BuiltinsMathTest,Asin_1)621 HWTEST_F_L0(BuiltinsMathTest, Asin_1)
622 {
623 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
624 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
625 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
626 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
627
628 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
629 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
630 TestHelper::TearDownFrame(thread_, prev);
631 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
632 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
633 }
634
635 // Math.asin(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Asin_2)636 HWTEST_F_L0(BuiltinsMathTest, Asin_2)
637 {
638 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
639 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
640 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
641 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
642
643 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
644 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
645 TestHelper::TearDownFrame(thread_, prev);
646 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
647 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
648 }
649
650 // Math.asin(null)
HWTEST_F_L0(BuiltinsMathTest,Asin_3)651 HWTEST_F_L0(BuiltinsMathTest, Asin_3)
652 {
653 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
654 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
655 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
656 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
657
658 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
659 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
660 TestHelper::TearDownFrame(thread_, prev);
661 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
662 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
663 }
664
665 // Math.asin(UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Asin_4)666 HWTEST_F_L0(BuiltinsMathTest, Asin_4)
667 {
668 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
669 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
670 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
671 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
672
673 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
674 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
675 TestHelper::TearDownFrame(thread_, prev);
676 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
677 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
678 }
679
680 // Math.asin(true)
HWTEST_F_L0(BuiltinsMathTest,Asin_5)681 HWTEST_F_L0(BuiltinsMathTest, Asin_5)
682 {
683 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
684 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
685 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
686 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
687
688 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
689 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
690 TestHelper::TearDownFrame(thread_, prev);
691 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
692 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
693 }
694
695 // Math.asin(false)
HWTEST_F_L0(BuiltinsMathTest,Asin_6)696 HWTEST_F_L0(BuiltinsMathTest, Asin_6)
697 {
698 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
699 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
700 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
701 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
702
703 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
704 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
705 TestHelper::TearDownFrame(thread_, prev);
706 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
707 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
708 }
709
710 // Math.asin(""")
HWTEST_F_L0(BuiltinsMathTest,Asin_7)711 HWTEST_F_L0(BuiltinsMathTest, Asin_7)
712 {
713 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
714 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
715 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
716 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
717 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
718
719 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
720 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
721 TestHelper::TearDownFrame(thread_, prev);
722 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
723 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
724 }
725
726 // Math.asin("1")
HWTEST_F_L0(BuiltinsMathTest,Asin_8)727 HWTEST_F_L0(BuiltinsMathTest, Asin_8)
728 {
729 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("1");
730 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
731 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
732 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
733 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
734
735 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
736 JSTaggedValue result = BuiltinsMath::Asin(ecmaRuntimeCallInfo);
737 TestHelper::TearDownFrame(thread_, prev);
738 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
739 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
740 }
741
742 // Math.asinh(-1)
HWTEST_F_L0(BuiltinsMathTest,Asinh)743 HWTEST_F_L0(BuiltinsMathTest, Asinh)
744 {
745 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
746 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
747 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
748 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
749
750 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
751 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
752 TestHelper::TearDownFrame(thread_, prev);
753 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.881373587019543);
754 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
755 }
756
757 // Math.asinh(1)
HWTEST_F_L0(BuiltinsMathTest,Asinh_1)758 HWTEST_F_L0(BuiltinsMathTest, Asinh_1)
759 {
760 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
761 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
762 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
763 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
764
765 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
766 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
767 TestHelper::TearDownFrame(thread_, prev);
768 TestHelper::TearDownFrame(thread_, prev);
769 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.881373587019543);
770 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
771 }
772
773 // Math.asinh(null)
HWTEST_F_L0(BuiltinsMathTest,Asinh_2)774 HWTEST_F_L0(BuiltinsMathTest, Asinh_2)
775 {
776 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
777 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
778 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
779 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
780
781 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
782 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
783 TestHelper::TearDownFrame(thread_, prev);
784 TestHelper::TearDownFrame(thread_, prev);
785 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
786 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
787 }
788
789 // Math.asinh(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Asinh_3)790 HWTEST_F_L0(BuiltinsMathTest, Asinh_3)
791 {
792 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
793 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
794 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
795 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
796
797 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
798 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
799 TestHelper::TearDownFrame(thread_, prev);
800 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
801 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
802 }
803
804 // Math.asinh(NEGATIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Asinh_4)805 HWTEST_F_L0(BuiltinsMathTest, Asinh_4)
806 {
807 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
808 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
809 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
810 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
811
812 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
813 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
814 TestHelper::TearDownFrame(thread_, prev);
815 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
816 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
817 }
818
819 // Math.asinh(true)
HWTEST_F_L0(BuiltinsMathTest,Asinh_5)820 HWTEST_F_L0(BuiltinsMathTest, Asinh_5)
821 {
822 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
823 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
824 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
825 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
826
827 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
828 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
829 TestHelper::TearDownFrame(thread_, prev);
830 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.881373587019543);
831 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
832 }
833
834 // Math.asinh(false)
HWTEST_F_L0(BuiltinsMathTest,Asinh_6)835 HWTEST_F_L0(BuiltinsMathTest, Asinh_6)
836 {
837 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
838 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
839 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
840 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
841
842 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
843 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
844 TestHelper::TearDownFrame(thread_, prev);
845 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
846 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
847 }
848
849 // Math.asinh("")
HWTEST_F_L0(BuiltinsMathTest,Asinh_7)850 HWTEST_F_L0(BuiltinsMathTest, Asinh_7)
851 {
852 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
853 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
854 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
855 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
856 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
857
858 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
859 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
860 TestHelper::TearDownFrame(thread_, prev);
861 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
862 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
863 }
864
865 // Math.asinh("-5.7")
HWTEST_F_L0(BuiltinsMathTest,Asinh_8)866 HWTEST_F_L0(BuiltinsMathTest, Asinh_8)
867 {
868 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-5.7");
869 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
870 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
871 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
872 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
873
874 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
875 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
876 TestHelper::TearDownFrame(thread_, prev);
877 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-2.44122070725561);
878 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
879 }
880
881 // Math.asinh(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Asinh_9)882 HWTEST_F_L0(BuiltinsMathTest, Asinh_9)
883 {
884 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
885 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
886 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
887 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
888
889 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
890 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
891 TestHelper::TearDownFrame(thread_, prev);
892 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
893 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
894 }
895
896 // Math.asinh(+0.0)
HWTEST_F_L0(BuiltinsMathTest,Asinh_10)897 HWTEST_F_L0(BuiltinsMathTest, Asinh_10)
898 {
899 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
900 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
901 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
902 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(+0.0));
903
904 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
905 JSTaggedValue result = BuiltinsMath::Asinh(ecmaRuntimeCallInfo);
906 TestHelper::TearDownFrame(thread_, prev);
907 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(+0.0);
908 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
909 }
910
911 // Math.atan(-1)
HWTEST_F_L0(BuiltinsMathTest,Atan)912 HWTEST_F_L0(BuiltinsMathTest, Atan)
913 {
914 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
915 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
916 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
917 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
918
919 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
920 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
921 TestHelper::TearDownFrame(thread_, prev);
922 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.7853981633974483);
923 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
924 }
925
926 // Math.atan(1)
HWTEST_F_L0(BuiltinsMathTest,Atan_1)927 HWTEST_F_L0(BuiltinsMathTest, Atan_1)
928 {
929 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
930 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
931 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
932 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
933
934 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
935 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
936 TestHelper::TearDownFrame(thread_, prev);
937 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.7853981633974483);
938 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
939 }
940
941 // Math.atan(null)
HWTEST_F_L0(BuiltinsMathTest,Atan_2)942 HWTEST_F_L0(BuiltinsMathTest, Atan_2)
943 {
944 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
945 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
946 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
947 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
948
949 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
950 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
951 TestHelper::TearDownFrame(thread_, prev);
952 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
953 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
954 }
955
956 // Math.atan(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Atan_3)957 HWTEST_F_L0(BuiltinsMathTest, Atan_3)
958 {
959 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
960 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
961 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
962 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
963
964 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
965 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
966 TestHelper::TearDownFrame(thread_, prev);
967 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
968 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
969 }
970
971 // Math.atan(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Atan_4)972 HWTEST_F_L0(BuiltinsMathTest, Atan_4)
973 {
974 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
975 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
976 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
977 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
978
979 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
980 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
981 TestHelper::TearDownFrame(thread_, prev);
982 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(BuiltinsMath::PI / 2);
983 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
984 }
985
986 // Math.atan(true)
HWTEST_F_L0(BuiltinsMathTest,Atan_5)987 HWTEST_F_L0(BuiltinsMathTest, Atan_5)
988 {
989 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
990 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
991 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
992 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
993
994 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
995 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
996 TestHelper::TearDownFrame(thread_, prev);
997 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.7853981633974483);
998 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
999 }
1000
1001 // Math.atan(false)
HWTEST_F_L0(BuiltinsMathTest,Atan_6)1002 HWTEST_F_L0(BuiltinsMathTest, Atan_6)
1003 {
1004 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1005 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1006 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1007 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1008
1009 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1010 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
1011 TestHelper::TearDownFrame(thread_, prev);
1012 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1013 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1014 }
1015
1016 // Math.atan("")
HWTEST_F_L0(BuiltinsMathTest,Atan_7)1017 HWTEST_F_L0(BuiltinsMathTest, Atan_7)
1018 {
1019 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII(" ");
1020 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1021 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1022 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1023 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1024
1025 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1026 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
1027 TestHelper::TearDownFrame(thread_, prev);
1028 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1029 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1030 }
1031
1032 // Math.atan("-1")
HWTEST_F_L0(BuiltinsMathTest,Atan_8)1033 HWTEST_F_L0(BuiltinsMathTest, Atan_8)
1034 {
1035 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-1");
1036 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1037 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1038 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1039 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1040
1041 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1042 JSTaggedValue result = BuiltinsMath::Atan(ecmaRuntimeCallInfo);
1043 TestHelper::TearDownFrame(thread_, prev);
1044 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.7853981633974483);
1045 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1046 }
1047
1048 // Math.atanh(-1)
HWTEST_F_L0(BuiltinsMathTest,Atanh)1049 HWTEST_F_L0(BuiltinsMathTest, Atanh)
1050 {
1051 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1052 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1053 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1054 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
1055
1056 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1057 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1058 TestHelper::TearDownFrame(thread_, prev);
1059 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
1060 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1061 }
1062
1063 // Math.atanh(1)
HWTEST_F_L0(BuiltinsMathTest,Atanh_1)1064 HWTEST_F_L0(BuiltinsMathTest, Atanh_1)
1065 {
1066 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1067 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1068 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1069 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1070
1071 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1072 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1073 TestHelper::TearDownFrame(thread_, prev);
1074 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
1075 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1076 }
1077
1078 // Math.atanh(null)
HWTEST_F_L0(BuiltinsMathTest,Atanh_2)1079 HWTEST_F_L0(BuiltinsMathTest, Atanh_2)
1080 {
1081 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1082 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1083 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1084 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
1085
1086 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1087 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1088 TestHelper::TearDownFrame(thread_, prev);
1089 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1090 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1091 }
1092
1093 // Math.atanh(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Atanh_3)1094 HWTEST_F_L0(BuiltinsMathTest, Atanh_3)
1095 {
1096 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1097 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1098 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1099 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1100
1101 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1102 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1103 TestHelper::TearDownFrame(thread_, prev);
1104 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1105 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1106 }
1107
1108 // Math.atanh(1.5)
HWTEST_F_L0(BuiltinsMathTest,Atanh_4)1109 HWTEST_F_L0(BuiltinsMathTest, Atanh_4)
1110 {
1111 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1112 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1113 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1114 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(1.5));
1115
1116 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1117 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1118 TestHelper::TearDownFrame(thread_, prev);
1119 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1120 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1121 }
1122
1123 // Math.atanh(true)
HWTEST_F_L0(BuiltinsMathTest,Atanh_5)1124 HWTEST_F_L0(BuiltinsMathTest, Atanh_5)
1125 {
1126 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1127 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1128 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1129 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
1130
1131 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1132 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1133 TestHelper::TearDownFrame(thread_, prev);
1134 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
1135 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1136 }
1137
1138 // Math.atanh(false)
HWTEST_F_L0(BuiltinsMathTest,Atanh_6)1139 HWTEST_F_L0(BuiltinsMathTest, Atanh_6)
1140 {
1141 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1142 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1143 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1144 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1145
1146 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1147 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1148 TestHelper::TearDownFrame(thread_, prev);
1149 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1150 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1151 }
1152
1153 // Math.atanh("")
HWTEST_F_L0(BuiltinsMathTest,Atanh_7)1154 HWTEST_F_L0(BuiltinsMathTest, Atanh_7)
1155 {
1156 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII(" ");
1157 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1158 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1159 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1160 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1161
1162 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1163 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1164 TestHelper::TearDownFrame(thread_, prev);
1165 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1166 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1167 }
1168
1169 // Math.atanh("-1")
HWTEST_F_L0(BuiltinsMathTest,Atanh_8)1170 HWTEST_F_L0(BuiltinsMathTest, Atanh_8)
1171 {
1172 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-1");
1173 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1174 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1175 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1176 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1177
1178 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1179 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1180 TestHelper::TearDownFrame(thread_, prev);
1181 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
1182 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1183 }
1184
1185 // Math.atanh(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Atanh_9)1186 HWTEST_F_L0(BuiltinsMathTest, Atanh_9)
1187 {
1188 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1189 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1190 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1191 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
1192
1193 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1194 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1195 TestHelper::TearDownFrame(thread_, prev);
1196 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
1197 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1198 }
1199
1200 // Math.atanh(+0.0)
HWTEST_F_L0(BuiltinsMathTest,Atanh_10)1201 HWTEST_F_L0(BuiltinsMathTest, Atanh_10)
1202 {
1203 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1204 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1205 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1206 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(+0.0));
1207
1208 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1209 JSTaggedValue result = BuiltinsMath::Atanh(ecmaRuntimeCallInfo);
1210 TestHelper::TearDownFrame(thread_, prev);
1211 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(+0.0);
1212 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1213 }
1214
1215 // Math.atan2(NaN, 1.5)
HWTEST_F_L0(BuiltinsMathTest,Atan2)1216 HWTEST_F_L0(BuiltinsMathTest, Atan2)
1217 {
1218 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1219 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1220 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1221 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::NAN_VALUE));
1222 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(1.5));
1223
1224 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1225 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1226 TestHelper::TearDownFrame(thread_, prev);
1227 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1228 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1229 }
1230
1231 // Math.atan2(-1, 1.5)
HWTEST_F_L0(BuiltinsMathTest,Atan2_1)1232 HWTEST_F_L0(BuiltinsMathTest, Atan2_1)
1233 {
1234 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1235 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1236 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1237 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
1238 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(1.5));
1239
1240 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1241 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1242 TestHelper::TearDownFrame(thread_, prev);
1243 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.5880026035475675);
1244 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1245 }
1246
1247 // Math.atan2(1, -0)
HWTEST_F_L0(BuiltinsMathTest,Atan2_2)1248 HWTEST_F_L0(BuiltinsMathTest, Atan2_2)
1249 {
1250 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1251 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1252 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1253 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1254 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(-0.0));
1255
1256 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1257 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1258 TestHelper::TearDownFrame(thread_, prev);
1259 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(BuiltinsMath::PI / 2);
1260 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1261 }
1262
1263 // Math.atan2(0, 1)
HWTEST_F_L0(BuiltinsMathTest,Atan2_3)1264 HWTEST_F_L0(BuiltinsMathTest, Atan2_3)
1265 {
1266 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1267 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1268 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1269 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1270 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
1271
1272 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1273 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1274 TestHelper::TearDownFrame(thread_, prev);
1275 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1276 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1277 }
1278
1279 // Math.atan2(0, -0)
HWTEST_F_L0(BuiltinsMathTest,Atan2_4)1280 HWTEST_F_L0(BuiltinsMathTest, Atan2_4)
1281 {
1282 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1283 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1284 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1285 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1286 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(-0.0));
1287
1288 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1289 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1290 TestHelper::TearDownFrame(thread_, prev);
1291 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(BuiltinsMath::PI);
1292 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1293 }
1294
1295 // Math.atan2(-0, 0)
HWTEST_F_L0(BuiltinsMathTest,Atan2_5)1296 HWTEST_F_L0(BuiltinsMathTest, Atan2_5)
1297 {
1298 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1299 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1300 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1301 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
1302 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
1303
1304 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1305 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1306 TestHelper::TearDownFrame(thread_, prev);
1307 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
1308 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1309 }
1310
1311 // Math.atan2(-0, -0)
HWTEST_F_L0(BuiltinsMathTest,Atan2_6)1312 HWTEST_F_L0(BuiltinsMathTest, Atan2_6)
1313 {
1314 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1315 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1316 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1317 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
1318 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(-0.0));
1319
1320 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1321 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1322 TestHelper::TearDownFrame(thread_, prev);
1323 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-BuiltinsMath::PI);
1324 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1325 }
1326
1327 // Math.atan2(true, false)
HWTEST_F_L0(BuiltinsMathTest,Atan2_7)1328 HWTEST_F_L0(BuiltinsMathTest, Atan2_7)
1329 {
1330 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1331 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1332 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1333 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
1334 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue::False());
1335
1336 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1337 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1338 TestHelper::TearDownFrame(thread_, prev);
1339 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5707963267948966);
1340 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1341 }
1342
1343 // Math.atan2(false, true)
HWTEST_F_L0(BuiltinsMathTest,Atan2_8)1344 HWTEST_F_L0(BuiltinsMathTest, Atan2_8)
1345 {
1346 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1347 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1348 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1349 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1350 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue::True());
1351
1352 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1353 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1354 TestHelper::TearDownFrame(thread_, prev);
1355 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1356 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1357 }
1358
1359 // Math.atan2("-1","")
HWTEST_F_L0(BuiltinsMathTest,Atan2_9)1360 HWTEST_F_L0(BuiltinsMathTest, Atan2_9)
1361 {
1362 JSHandle<EcmaString> test_1 = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-1");
1363 JSHandle<EcmaString> test_2 = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
1364 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1365 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1366 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1367 ecmaRuntimeCallInfo->SetCallArg(0, test_1.GetTaggedValue());
1368 ecmaRuntimeCallInfo->SetCallArg(1, test_2.GetTaggedValue());
1369
1370 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1371 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1372 TestHelper::TearDownFrame(thread_, prev);
1373 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.5707963267948966);
1374 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1375 }
1376
1377 // Math.atan2("0.23","0.72")
HWTEST_F_L0(BuiltinsMathTest,Atan2_10)1378 HWTEST_F_L0(BuiltinsMathTest, Atan2_10)
1379 {
1380 JSHandle<EcmaString> test_1 = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.23");
1381 JSHandle<EcmaString> test_2 = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.72");
1382 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1383 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1384 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1385 ecmaRuntimeCallInfo->SetCallArg(0, test_1.GetTaggedValue());
1386 ecmaRuntimeCallInfo->SetCallArg(1, test_2.GetTaggedValue());
1387
1388 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1389 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1390 TestHelper::TearDownFrame(thread_, prev);
1391 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.3091989123270746);
1392 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1393 }
1394
1395 // Math.atan2(-NaN, 1.5)
HWTEST_F_L0(BuiltinsMathTest,Atan2_11)1396 HWTEST_F_L0(BuiltinsMathTest, Atan2_11)
1397 {
1398 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
1399 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1400 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1401 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1402 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(-1.5));
1403
1404 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1405 JSTaggedValue result = BuiltinsMath::Atan2(ecmaRuntimeCallInfo);
1406 TestHelper::TearDownFrame(thread_, prev);
1407 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1408 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1409 }
1410
1411 // Math.cbrt(0)
HWTEST_F_L0(BuiltinsMathTest,Cbrt)1412 HWTEST_F_L0(BuiltinsMathTest, Cbrt)
1413 {
1414 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1415 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1416 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1417 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1418
1419 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1420 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1421 TestHelper::TearDownFrame(thread_, prev);
1422 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1423 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1424 }
1425
1426 // Math.cbrt(-0)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_1)1427 HWTEST_F_L0(BuiltinsMathTest, Cbrt_1)
1428 {
1429 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1430 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1431 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1432 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
1433
1434 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1435 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1436 TestHelper::TearDownFrame(thread_, prev);
1437 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
1438 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1439 }
1440
1441 // Math.cbrt(NEGATIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_2)1442 HWTEST_F_L0(BuiltinsMathTest, Cbrt_2)
1443 {
1444 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1445 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1446 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1447 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
1448
1449 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1450 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1451 TestHelper::TearDownFrame(thread_, prev);
1452 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
1453 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1454 }
1455
1456 // Math.cbrt(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_3)1457 HWTEST_F_L0(BuiltinsMathTest, Cbrt_3)
1458 {
1459 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1460 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1461 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1462 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
1463
1464 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1465 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1466 TestHelper::TearDownFrame(thread_, prev);
1467 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
1468 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1469 }
1470
1471 // Math.cbrt(VALUE_UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_4)1472 HWTEST_F_L0(BuiltinsMathTest, Cbrt_4)
1473 {
1474 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1475 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1476 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1477 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
1478
1479 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1480 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1481 TestHelper::TearDownFrame(thread_, prev);
1482 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1483 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1484 }
1485
1486 // Math.cbrt(true)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_5)1487 HWTEST_F_L0(BuiltinsMathTest, Cbrt_5)
1488 {
1489 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1490 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1491 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1492 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
1493
1494 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1495 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1496 TestHelper::TearDownFrame(thread_, prev);
1497 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1498 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1499 }
1500
1501 // Math.cbrt(false)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_6)1502 HWTEST_F_L0(BuiltinsMathTest, Cbrt_6)
1503 {
1504 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1505 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1506 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1507 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1508
1509 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1510 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1511 TestHelper::TearDownFrame(thread_, prev);
1512 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1513 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1514 }
1515
1516 // Math.cbrt("")
HWTEST_F_L0(BuiltinsMathTest,Cbrt_7)1517 HWTEST_F_L0(BuiltinsMathTest, Cbrt_7)
1518 {
1519 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII(" ");
1520 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1521 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1522 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1523 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1524
1525 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1526 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1527 TestHelper::TearDownFrame(thread_, prev);
1528 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1529 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1530 }
1531
1532 // Math.cbrt("1.23")
HWTEST_F_L0(BuiltinsMathTest,Cbrt_8)1533 HWTEST_F_L0(BuiltinsMathTest, Cbrt_8)
1534 {
1535 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("1.23");
1536 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1537 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1538 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1539 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1540
1541 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1542 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1543 TestHelper::TearDownFrame(thread_, prev);
1544 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0714412696907731);
1545 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1546 }
1547
1548 // Math.cbrt(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Cbrt_9)1549 HWTEST_F_L0(BuiltinsMathTest, Cbrt_9)
1550 {
1551 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1552 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1553 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1554 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1555
1556 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1557 JSTaggedValue result = BuiltinsMath::Cbrt(ecmaRuntimeCallInfo);
1558 TestHelper::TearDownFrame(thread_, prev);
1559 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1560 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1561 }
1562
1563 // Math.ceil(3.25)
HWTEST_F_L0(BuiltinsMathTest,Ceil)1564 HWTEST_F_L0(BuiltinsMathTest, Ceil)
1565 {
1566 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1567 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1568 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1569 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(3.25));
1570
1571 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1572 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1573 TestHelper::TearDownFrame(thread_, prev);
1574 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(4.0);
1575 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1576 }
1577
1578 // Math.ceil(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Ceil_1)1579 HWTEST_F_L0(BuiltinsMathTest, Ceil_1)
1580 {
1581 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1582 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1583 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1584 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
1585
1586 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1587 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1588 TestHelper::TearDownFrame(thread_, prev);
1589 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
1590 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1591 }
1592
1593 // Math.ceil(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Ceil_2)1594 HWTEST_F_L0(BuiltinsMathTest, Ceil_2)
1595 {
1596 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1597 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1598 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1599 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
1600
1601 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1602 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1603 TestHelper::TearDownFrame(thread_, prev);
1604 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
1605 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1606 }
1607
1608 // Math.ceil(null)
HWTEST_F_L0(BuiltinsMathTest,Ceil_3)1609 HWTEST_F_L0(BuiltinsMathTest, Ceil_3)
1610 {
1611 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1612 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1613 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1614 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
1615
1616 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1617 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1618 TestHelper::TearDownFrame(thread_, prev);
1619 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1620 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1621 }
1622
1623 // Math.ceil(0)
HWTEST_F_L0(BuiltinsMathTest,Ceil_4)1624 HWTEST_F_L0(BuiltinsMathTest, Ceil_4)
1625 {
1626 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1627 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1628 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1629 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1630
1631 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1632 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1633 TestHelper::TearDownFrame(thread_, prev);
1634 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1635 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1636 }
1637
1638 // Math.ceil(true)
HWTEST_F_L0(BuiltinsMathTest,Ceil_5)1639 HWTEST_F_L0(BuiltinsMathTest, Ceil_5)
1640 {
1641 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1642 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1643 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1644 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
1645
1646 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1647 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1648 TestHelper::TearDownFrame(thread_, prev);
1649 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1650 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1651 }
1652
1653 // Math.ceil(false)
HWTEST_F_L0(BuiltinsMathTest,Ceil_6)1654 HWTEST_F_L0(BuiltinsMathTest, Ceil_6)
1655 {
1656 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1657 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1658 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1659 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1660
1661 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1662 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1663 TestHelper::TearDownFrame(thread_, prev);
1664 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1665 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1666 }
1667
1668 // Math.ceil("")
HWTEST_F_L0(BuiltinsMathTest,Ceil_7)1669 HWTEST_F_L0(BuiltinsMathTest, Ceil_7)
1670 {
1671 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
1672 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1673 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1674 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1675 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1676
1677 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1678 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1679 TestHelper::TearDownFrame(thread_, prev);
1680 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
1681 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1682 }
1683
1684 // Math.ceil("3.23")
HWTEST_F_L0(BuiltinsMathTest,Ceil_8)1685 HWTEST_F_L0(BuiltinsMathTest, Ceil_8)
1686 {
1687 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("3.23");
1688 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1689 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1690 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1691 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1692
1693 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1694 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1695 TestHelper::TearDownFrame(thread_, prev);
1696 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(4.0);
1697 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1698 }
1699
1700 // Math.ceil(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Ceil_9)1701 HWTEST_F_L0(BuiltinsMathTest, Ceil_9)
1702 {
1703 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1704 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1705 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1706 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1707
1708 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1709 JSTaggedValue result = BuiltinsMath::Ceil(ecmaRuntimeCallInfo);
1710 TestHelper::TearDownFrame(thread_, prev);
1711 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1712 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1713 }
1714
1715 // Math.cos(0)
HWTEST_F_L0(BuiltinsMathTest,Cos)1716 HWTEST_F_L0(BuiltinsMathTest, Cos)
1717 {
1718 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1719 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1720 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1721 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1722
1723 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1724 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1725 TestHelper::TearDownFrame(thread_, prev);
1726 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1727 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1728 }
1729
1730 // Math.cos(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Cos_1)1731 HWTEST_F_L0(BuiltinsMathTest, Cos_1)
1732 {
1733 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1734 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1735 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1736 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1737
1738 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1739 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1740 TestHelper::TearDownFrame(thread_, prev);
1741 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1742 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1743 }
1744
1745 // Math.cos(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Cos_2)1746 HWTEST_F_L0(BuiltinsMathTest, Cos_2)
1747 {
1748 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1749 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1750 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1751 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
1752
1753 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1754 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1755 TestHelper::TearDownFrame(thread_, prev);
1756 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1757 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1758 }
1759
1760 // Math.cos(-POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Cos_3)1761 HWTEST_F_L0(BuiltinsMathTest, Cos_3)
1762 {
1763 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1764 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1765 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1766 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
1767
1768 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1769 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1770 TestHelper::TearDownFrame(thread_, prev);
1771 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1772 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1773 }
1774
1775 // Math.cos(true)
HWTEST_F_L0(BuiltinsMathTest,Cos_4)1776 HWTEST_F_L0(BuiltinsMathTest, Cos_4)
1777 {
1778 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1779 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1780 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1781 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
1782
1783 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1784 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1785 TestHelper::TearDownFrame(thread_, prev);
1786 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.5403023058681398);
1787 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1788 }
1789
1790 // Math.cos(false)
HWTEST_F_L0(BuiltinsMathTest,Cos_5)1791 HWTEST_F_L0(BuiltinsMathTest, Cos_5)
1792 {
1793 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1794 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1795 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1796 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1797
1798 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1799 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1800 TestHelper::TearDownFrame(thread_, prev);
1801 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1802 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1803 }
1804
1805 // Math.cos("")
HWTEST_F_L0(BuiltinsMathTest,Cos_6)1806 HWTEST_F_L0(BuiltinsMathTest, Cos_6)
1807 {
1808 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
1809 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1810 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1811 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1812 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1813
1814 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1815 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1816 TestHelper::TearDownFrame(thread_, prev);
1817 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1818 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1819 }
1820
1821 // Math.cos("3.23")
HWTEST_F_L0(BuiltinsMathTest,Cos_7)1822 HWTEST_F_L0(BuiltinsMathTest, Cos_7)
1823 {
1824 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("3.23");
1825 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1826 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1827 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1828 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1829
1830 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1831 JSTaggedValue result = BuiltinsMath::Cos(ecmaRuntimeCallInfo);
1832 TestHelper::TearDownFrame(thread_, prev);
1833 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.9960946152060809);
1834 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1835 }
1836
1837 // Math.cosh(0)
HWTEST_F_L0(BuiltinsMathTest,Cosh)1838 HWTEST_F_L0(BuiltinsMathTest, Cosh)
1839 {
1840 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1841 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1842 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1843 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1844
1845 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1846 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1847 TestHelper::TearDownFrame(thread_, prev);
1848 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1849 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1850 }
1851
1852 // Math.cosh(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Cosh_1)1853 HWTEST_F_L0(BuiltinsMathTest, Cosh_1)
1854 {
1855 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1856 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1857 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1858 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1859
1860 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1861 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1862 TestHelper::TearDownFrame(thread_, prev);
1863 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1864 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1865 }
1866
1867 // Math.cosh(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Cosh_2)1868 HWTEST_F_L0(BuiltinsMathTest, Cosh_2)
1869 {
1870 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1871 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1872 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1873 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
1874
1875 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1876 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1877 TestHelper::TearDownFrame(thread_, prev);
1878 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
1879 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1880 }
1881
1882 // Math.cosh(-POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Cosh_3)1883 HWTEST_F_L0(BuiltinsMathTest, Cosh_3)
1884 {
1885 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1886 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1887 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1888 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
1889
1890 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1891 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1892 TestHelper::TearDownFrame(thread_, prev);
1893 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
1894 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1895 }
1896
1897 // Math.cosh(true)
HWTEST_F_L0(BuiltinsMathTest,Cosh_4)1898 HWTEST_F_L0(BuiltinsMathTest, Cosh_4)
1899 {
1900 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1901 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1902 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1903 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
1904
1905 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1906 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1907 TestHelper::TearDownFrame(thread_, prev);
1908 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5430806348152437);
1909 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1910 }
1911
1912 // Math.cosh(false)
HWTEST_F_L0(BuiltinsMathTest,Cosh_5)1913 HWTEST_F_L0(BuiltinsMathTest, Cosh_5)
1914 {
1915 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1916 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1917 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1918 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
1919
1920 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1921 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1922 TestHelper::TearDownFrame(thread_, prev);
1923 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1924 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1925 }
1926
1927 // Math.cosh("")
HWTEST_F_L0(BuiltinsMathTest,Cosh_6)1928 HWTEST_F_L0(BuiltinsMathTest, Cosh_6)
1929 {
1930 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII(" ");
1931 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1932 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1933 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1934 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1935
1936 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1937 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1938 TestHelper::TearDownFrame(thread_, prev);
1939 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1940 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1941 }
1942
1943 // Math.cosh("3.23")
HWTEST_F_L0(BuiltinsMathTest,Cosh_7)1944 HWTEST_F_L0(BuiltinsMathTest, Cosh_7)
1945 {
1946 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("3.23");
1947 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1948 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1949 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1950 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
1951
1952 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1953 JSTaggedValue result = BuiltinsMath::Cosh(ecmaRuntimeCallInfo);
1954 TestHelper::TearDownFrame(thread_, prev);
1955 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(12.659607234875645);
1956 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1957 }
1958
1959 // Math.exp(0)
HWTEST_F_L0(BuiltinsMathTest,Exp)1960 HWTEST_F_L0(BuiltinsMathTest, Exp)
1961 {
1962 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1963 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1964 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1965 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1966
1967 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1968 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
1969 TestHelper::TearDownFrame(thread_, prev);
1970 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
1971 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1972 }
1973
1974 // Math.exp(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Exp_1)1975 HWTEST_F_L0(BuiltinsMathTest, Exp_1)
1976 {
1977 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1978 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1979 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1980 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
1981
1982 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1983 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
1984 TestHelper::TearDownFrame(thread_, prev);
1985 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
1986 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
1987 }
1988
1989 // Math.exp(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Exp_2)1990 HWTEST_F_L0(BuiltinsMathTest, Exp_2)
1991 {
1992 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
1993 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1994 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
1995 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
1996
1997 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
1998 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
1999 TestHelper::TearDownFrame(thread_, prev);
2000 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2001 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2002 }
2003
2004 // Math.exp(-POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Exp_3)2005 HWTEST_F_L0(BuiltinsMathTest, Exp_3)
2006 {
2007 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2008 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2009 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2010 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
2011
2012 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2013 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
2014 TestHelper::TearDownFrame(thread_, prev);
2015 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2016 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2017 }
2018
2019 // Math.exp(true)
HWTEST_F_L0(BuiltinsMathTest,Exp_4)2020 HWTEST_F_L0(BuiltinsMathTest, Exp_4)
2021 {
2022 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2023 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2024 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2025 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2026
2027 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2028 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
2029 TestHelper::TearDownFrame(thread_, prev);
2030 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(2.718281828459045);
2031 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2032 }
2033
2034 // Math.exp(false)
HWTEST_F_L0(BuiltinsMathTest,Exp_5)2035 HWTEST_F_L0(BuiltinsMathTest, Exp_5)
2036 {
2037 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2038 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2039 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2040 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
2041
2042 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2043 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
2044 TestHelper::TearDownFrame(thread_, prev);
2045 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
2046 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2047 }
2048
2049 // Math.exp("")
HWTEST_F_L0(BuiltinsMathTest,Exp_6)2050 HWTEST_F_L0(BuiltinsMathTest, Exp_6)
2051 {
2052 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("");
2053 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2054 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2055 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2056 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2057
2058 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2059 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
2060 TestHelper::TearDownFrame(thread_, prev);
2061 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
2062 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2063 }
2064
2065 // Math.exp("-3.23")
HWTEST_F_L0(BuiltinsMathTest,Exp_7)2066 HWTEST_F_L0(BuiltinsMathTest, Exp_7)
2067 {
2068 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-3.23");
2069 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2070 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2071 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2072 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2073
2074 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2075 JSTaggedValue result = BuiltinsMath::Exp(ecmaRuntimeCallInfo);
2076 TestHelper::TearDownFrame(thread_, prev);
2077 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.039557498788398725);
2078 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2079 }
2080
2081 // Math.Expm1(0)
HWTEST_F_L0(BuiltinsMathTest,Expm1)2082 HWTEST_F_L0(BuiltinsMathTest, Expm1)
2083 {
2084 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2085 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2086 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2087 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
2088
2089 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2090 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2091 TestHelper::TearDownFrame(thread_, prev);
2092 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2093 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2094 }
2095
2096 // Math.Expm1(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Expm1_1)2097 HWTEST_F_L0(BuiltinsMathTest, Expm1_1)
2098 {
2099 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2100 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2101 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2102 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
2103
2104 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2105 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2106 TestHelper::TearDownFrame(thread_, prev);
2107 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
2108 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2109 }
2110
2111 // Math.Expm1(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Expm1_2)2112 HWTEST_F_L0(BuiltinsMathTest, Expm1_2)
2113 {
2114 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2115 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2116 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2117 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2118
2119 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2120 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2121 TestHelper::TearDownFrame(thread_, prev);
2122 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2123 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2124 }
2125
2126 // Math.Expm1(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Expm1_3)2127 HWTEST_F_L0(BuiltinsMathTest, Expm1_3)
2128 {
2129 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2130 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2131 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2132 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
2133
2134 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2135 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2136 TestHelper::TearDownFrame(thread_, prev);
2137 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2138 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2139 }
2140
2141 // Math.Expm1(-POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Expm1_4)2142 HWTEST_F_L0(BuiltinsMathTest, Expm1_4)
2143 {
2144 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2145 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2146 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2147 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
2148
2149 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2150 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2151 TestHelper::TearDownFrame(thread_, prev);
2152 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.0);
2153 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2154 }
2155
2156 // Math.expm1(true)
HWTEST_F_L0(BuiltinsMathTest,Expm1_5)2157 HWTEST_F_L0(BuiltinsMathTest, Expm1_5)
2158 {
2159 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2160 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2161 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2162 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2163
2164 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2165 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2166 TestHelper::TearDownFrame(thread_, prev);
2167 double expect = 1.718281828459045;
2168 ASSERT_TRUE(result.IsDouble());
2169 ASSERT_TRUE(std::abs(result.GetDouble() - expect) < 0.00000001);
2170 }
2171
2172 // Math.expm1(false)
HWTEST_F_L0(BuiltinsMathTest,Expm1_6)2173 HWTEST_F_L0(BuiltinsMathTest, Expm1_6)
2174 {
2175 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2176 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2177 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2178 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
2179
2180 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2181 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2182 TestHelper::TearDownFrame(thread_, prev);
2183 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2184 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2185 }
2186
2187 // Math.expm1("")
HWTEST_F_L0(BuiltinsMathTest,Expm1_7)2188 HWTEST_F_L0(BuiltinsMathTest, Expm1_7)
2189 {
2190 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII(" ");
2191 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2192 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2193 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2194 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2195
2196 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2197 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2198 TestHelper::TearDownFrame(thread_, prev);
2199 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2200 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2201 }
2202
2203 // Math.expm1("-3.23")
HWTEST_F_L0(BuiltinsMathTest,Expm1_8)2204 HWTEST_F_L0(BuiltinsMathTest, Expm1_8)
2205 {
2206 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-3.23");
2207 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2208 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2209 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2210 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2211
2212 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2213 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2214 TestHelper::TearDownFrame(thread_, prev);
2215 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.9604425012116012);
2216 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2217 }
2218
2219 // Math.expm1("0x12")
HWTEST_F_L0(BuiltinsMathTest,Expm1_9)2220 HWTEST_F_L0(BuiltinsMathTest, Expm1_9)
2221 {
2222 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0x12");
2223 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2224 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2225 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2226 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2227
2228 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2229 JSTaggedValue result = BuiltinsMath::Expm1(ecmaRuntimeCallInfo);
2230 TestHelper::TearDownFrame(thread_, prev);
2231 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(65659968.13733051);
2232 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2233 }
2234
2235 // Math.floor(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Floor)2236 HWTEST_F_L0(BuiltinsMathTest, Floor)
2237 {
2238 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2239 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2240 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2241 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
2242
2243 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2244 JSTaggedValue result = BuiltinsMath::Floor(ecmaRuntimeCallInfo);
2245 TestHelper::TearDownFrame(thread_, prev);
2246 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
2247 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2248 }
2249
2250 // Math.floor(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Floor_1)2251 HWTEST_F_L0(BuiltinsMathTest, Floor_1)
2252 {
2253 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2254 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2255 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2256 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2257
2258 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2259 JSTaggedValue result = BuiltinsMath::Floor(ecmaRuntimeCallInfo);
2260 TestHelper::TearDownFrame(thread_, prev);
2261 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2262 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2263 }
2264
2265 // Math.floor(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Floor_2)2266 HWTEST_F_L0(BuiltinsMathTest, Floor_2)
2267 {
2268 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2269 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2270 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2271 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
2272
2273 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2274 JSTaggedValue result = BuiltinsMath::Floor(ecmaRuntimeCallInfo);
2275 TestHelper::TearDownFrame(thread_, prev);
2276 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2277 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2278 }
2279
2280 // Math.floor(true)
HWTEST_F_L0(BuiltinsMathTest,Floor_3)2281 HWTEST_F_L0(BuiltinsMathTest, Floor_3)
2282 {
2283 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2284 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2285 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2286 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2287
2288 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2289 JSTaggedValue result = BuiltinsMath::Floor(ecmaRuntimeCallInfo);
2290 TestHelper::TearDownFrame(thread_, prev);
2291 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
2292 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2293 }
2294
2295 // Math.floor("-3.23")
HWTEST_F_L0(BuiltinsMathTest,Floor_4)2296 HWTEST_F_L0(BuiltinsMathTest, Floor_4)
2297 {
2298 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-3.23");
2299 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2300 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2301 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2302 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2303
2304 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2305 JSTaggedValue result = BuiltinsMath::Floor(ecmaRuntimeCallInfo);
2306 TestHelper::TearDownFrame(thread_, prev);
2307 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-4.0);
2308 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2309 }
2310
2311 // Math.log(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Log)2312 HWTEST_F_L0(BuiltinsMathTest, Log)
2313 {
2314 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2315 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2316 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2317 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
2318
2319 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2320 JSTaggedValue result = BuiltinsMath::Log(ecmaRuntimeCallInfo);
2321 TestHelper::TearDownFrame(thread_, prev);
2322 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
2323 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2324 }
2325
2326 // Math.log(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Log_1)2327 HWTEST_F_L0(BuiltinsMathTest, Log_1)
2328 {
2329 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2330 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2331 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2332 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2333
2334 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2335 JSTaggedValue result = BuiltinsMath::Log(ecmaRuntimeCallInfo);
2336 TestHelper::TearDownFrame(thread_, prev);
2337 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2338 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2339 }
2340
2341 // Math.log(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Log_2)2342 HWTEST_F_L0(BuiltinsMathTest, Log_2)
2343 {
2344 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2345 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2346 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2347 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
2348
2349 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2350 JSTaggedValue result = BuiltinsMath::Log(ecmaRuntimeCallInfo);
2351 TestHelper::TearDownFrame(thread_, prev);
2352 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2353 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2354 }
2355
2356 // Math.log(true)
HWTEST_F_L0(BuiltinsMathTest,Log_3)2357 HWTEST_F_L0(BuiltinsMathTest, Log_3)
2358 {
2359 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2360 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2361 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2362 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2363
2364 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2365 JSTaggedValue result = BuiltinsMath::Log(ecmaRuntimeCallInfo);
2366 TestHelper::TearDownFrame(thread_, prev);
2367 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2368 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2369 }
2370
2371 // Math.log("-3.23")
HWTEST_F_L0(BuiltinsMathTest,Log_4)2372 HWTEST_F_L0(BuiltinsMathTest, Log_4)
2373 {
2374 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-3.23");
2375 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2376 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2377 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2378 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2379
2380 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2381 JSTaggedValue result = BuiltinsMath::Log(ecmaRuntimeCallInfo);
2382 TestHelper::TearDownFrame(thread_, prev);
2383 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2384 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2385 }
2386
2387 // Math.log(0.12)
HWTEST_F_L0(BuiltinsMathTest,Log_5)2388 HWTEST_F_L0(BuiltinsMathTest, Log_5)
2389 {
2390 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2391 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2392 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2393 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(0.12));
2394
2395 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2396 JSTaggedValue result = BuiltinsMath::Log(ecmaRuntimeCallInfo);
2397 TestHelper::TearDownFrame(thread_, prev);
2398 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-2.120263536200091);
2399 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2400 }
2401
2402 // Math.log1p(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Log1p)2403 HWTEST_F_L0(BuiltinsMathTest, Log1p)
2404 {
2405 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2406 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2407 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2408 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
2409
2410 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2411 JSTaggedValue result = BuiltinsMath::Log1p(ecmaRuntimeCallInfo);
2412 TestHelper::TearDownFrame(thread_, prev);
2413 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
2414 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2415 }
2416
2417 // Math.log1p(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Log1p_1)2418 HWTEST_F_L0(BuiltinsMathTest, Log1p_1)
2419 {
2420 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2421 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2422 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2423 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2424
2425 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2426 JSTaggedValue result = BuiltinsMath::Log1p(ecmaRuntimeCallInfo);
2427 TestHelper::TearDownFrame(thread_, prev);
2428 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2429 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2430 }
2431
2432 // Math.log1p(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Log1p_2)2433 HWTEST_F_L0(BuiltinsMathTest, Log1p_2)
2434 {
2435 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2436 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2437 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2438 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
2439
2440 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2441 JSTaggedValue result = BuiltinsMath::Log1p(ecmaRuntimeCallInfo);
2442 TestHelper::TearDownFrame(thread_, prev);
2443 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2444 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2445 }
2446
2447 // Math.log1p(true)
HWTEST_F_L0(BuiltinsMathTest,Log1p_3)2448 HWTEST_F_L0(BuiltinsMathTest, Log1p_3)
2449 {
2450 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2451 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2452 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2453 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2454
2455 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2456 JSTaggedValue result = BuiltinsMath::Log1p(ecmaRuntimeCallInfo);
2457 TestHelper::TearDownFrame(thread_, prev);
2458 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.6931471805599453);
2459 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2460 }
2461
2462 // Math.log1p("-3.23")
HWTEST_F_L0(BuiltinsMathTest,Log1p_4)2463 HWTEST_F_L0(BuiltinsMathTest, Log1p_4)
2464 {
2465 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-3.23");
2466 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2467 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2468 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2469 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2470
2471 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2472 JSTaggedValue result = BuiltinsMath::Log1p(ecmaRuntimeCallInfo);
2473 TestHelper::TearDownFrame(thread_, prev);
2474 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2475 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2476 }
2477
2478 // Math.log1p(0.12)
HWTEST_F_L0(BuiltinsMathTest,Log1p_5)2479 HWTEST_F_L0(BuiltinsMathTest, Log1p_5)
2480 {
2481 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2482 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2483 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2484 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(0.12));
2485
2486 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2487 JSTaggedValue result = BuiltinsMath::Log1p(ecmaRuntimeCallInfo);
2488 TestHelper::TearDownFrame(thread_, prev);
2489 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.11332868530700317);
2490 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2491 }
2492
2493 // Math.log10(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Log10)2494 HWTEST_F_L0(BuiltinsMathTest, Log10)
2495 {
2496 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2497 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2498 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2499 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
2500
2501 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2502 JSTaggedValue result = BuiltinsMath::Log10(ecmaRuntimeCallInfo);
2503 TestHelper::TearDownFrame(thread_, prev);
2504 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
2505 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2506 }
2507
2508 // Math.Log10(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Log10_1)2509 HWTEST_F_L0(BuiltinsMathTest, Log10_1)
2510 {
2511 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2512 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2513 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2514 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2515
2516 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2517 JSTaggedValue result = BuiltinsMath::Log10(ecmaRuntimeCallInfo);
2518 TestHelper::TearDownFrame(thread_, prev);
2519 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2520 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2521 }
2522
2523 // Math.Log10(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Log10_2)2524 HWTEST_F_L0(BuiltinsMathTest, Log10_2)
2525 {
2526 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2527 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2528 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2529 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
2530
2531 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2532 JSTaggedValue result = BuiltinsMath::Log10(ecmaRuntimeCallInfo);
2533 TestHelper::TearDownFrame(thread_, prev);
2534 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2535 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2536 }
2537
2538 // Math.Log10(true)
HWTEST_F_L0(BuiltinsMathTest,Log10_3)2539 HWTEST_F_L0(BuiltinsMathTest, Log10_3)
2540 {
2541 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2542 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2543 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2544 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2545
2546 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2547 JSTaggedValue result = BuiltinsMath::Log10(ecmaRuntimeCallInfo);
2548 TestHelper::TearDownFrame(thread_, prev);
2549 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2550 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2551 }
2552
2553 // Math.Log10("2")
HWTEST_F_L0(BuiltinsMathTest,Log10_4)2554 HWTEST_F_L0(BuiltinsMathTest, Log10_4)
2555 {
2556 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("2");
2557 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2558 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2559 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2560 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2561
2562 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2563 JSTaggedValue result = BuiltinsMath::Log10(ecmaRuntimeCallInfo);
2564 TestHelper::TearDownFrame(thread_, prev);
2565 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.3010299956639812);
2566 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2567 }
2568
2569 // Math.Log10(0.12)
HWTEST_F_L0(BuiltinsMathTest,Log10_5)2570 HWTEST_F_L0(BuiltinsMathTest, Log10_5)
2571 {
2572 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2573 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2574 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2575 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(0.12));
2576
2577 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2578 JSTaggedValue result = BuiltinsMath::Log10(ecmaRuntimeCallInfo);
2579 TestHelper::TearDownFrame(thread_, prev);
2580 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.9208187539523752);
2581 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2582 }
2583
2584 // Math.log2(-0.0)
HWTEST_F_L0(BuiltinsMathTest,Log2)2585 HWTEST_F_L0(BuiltinsMathTest, Log2)
2586 {
2587 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2588 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2589 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2590 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
2591
2592 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2593 JSTaggedValue result = BuiltinsMath::Log2(ecmaRuntimeCallInfo);
2594 TestHelper::TearDownFrame(thread_, prev);
2595 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
2596 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2597 }
2598
2599 // Math.log2(-NAN)
HWTEST_F_L0(BuiltinsMathTest,Log2_1)2600 HWTEST_F_L0(BuiltinsMathTest, Log2_1)
2601 {
2602 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2603 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2604 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2605 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2606
2607 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2608 JSTaggedValue result = BuiltinsMath::Log2(ecmaRuntimeCallInfo);
2609 TestHelper::TearDownFrame(thread_, prev);
2610 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2611 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2612 }
2613
2614 // Math.log2(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Log2_2)2615 HWTEST_F_L0(BuiltinsMathTest, Log2_2)
2616 {
2617 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2618 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2619 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2620 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
2621
2622 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2623 JSTaggedValue result = BuiltinsMath::Log2(ecmaRuntimeCallInfo);
2624 TestHelper::TearDownFrame(thread_, prev);
2625 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2626 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2627 }
2628
2629 // Math.log2(true)
HWTEST_F_L0(BuiltinsMathTest,Log2_3)2630 HWTEST_F_L0(BuiltinsMathTest, Log2_3)
2631 {
2632 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2633 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2634 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2635 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
2636
2637 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2638 JSTaggedValue result = BuiltinsMath::Log2(ecmaRuntimeCallInfo);
2639 TestHelper::TearDownFrame(thread_, prev);
2640 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2641 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2642 }
2643
2644 // Math.log2("2")
HWTEST_F_L0(BuiltinsMathTest,Log2_4)2645 HWTEST_F_L0(BuiltinsMathTest, Log2_4)
2646 {
2647 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("2");
2648 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2649 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2650 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2651 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2652
2653 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2654 JSTaggedValue result = BuiltinsMath::Log2(ecmaRuntimeCallInfo);
2655 TestHelper::TearDownFrame(thread_, prev);
2656 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
2657 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2658 }
2659
2660 // Math.log2(1)
HWTEST_F_L0(BuiltinsMathTest,Log2_5)2661 HWTEST_F_L0(BuiltinsMathTest, Log2_5)
2662 {
2663 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2664 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2665 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2666 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(1)));
2667
2668 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2669 JSTaggedValue result = BuiltinsMath::Log2(ecmaRuntimeCallInfo);
2670 TestHelper::TearDownFrame(thread_, prev);
2671 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
2672 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2673 }
2674
2675 // Math.Max(NaN,1,POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Max)2676 HWTEST_F_L0(BuiltinsMathTest, Max)
2677 {
2678 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2679 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2680 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2681 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::NAN_VALUE));
2682 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
2683 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(base::POSITIVE_INFINITY));
2684
2685 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2686 JSTaggedValue result = BuiltinsMath::Max(ecmaRuntimeCallInfo);
2687 TestHelper::TearDownFrame(thread_, prev);
2688 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2689 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2690 }
2691
2692 // Math.Max()
HWTEST_F_L0(BuiltinsMathTest,Max_1)2693 HWTEST_F_L0(BuiltinsMathTest, Max_1)
2694 {
2695 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
2696 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2697 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2698
2699 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2700 JSTaggedValue result = BuiltinsMath::Max(ecmaRuntimeCallInfo);
2701 TestHelper::TearDownFrame(thread_, prev);
2702 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
2703 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2704 }
2705
2706 // Math.Max("3",100,2.5)
HWTEST_F_L0(BuiltinsMathTest,Max_2)2707 HWTEST_F_L0(BuiltinsMathTest, Max_2)
2708 {
2709 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("3");
2710 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2711 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2712 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2713 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2714 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(100)));
2715 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(2.5));
2716
2717 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2718 JSTaggedValue result = BuiltinsMath::Max(ecmaRuntimeCallInfo);
2719 TestHelper::TearDownFrame(thread_, prev);
2720 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(100);
2721 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2722 }
2723
2724 // Math.Max(3,"100",-101.5)
HWTEST_F_L0(BuiltinsMathTest,Max_3)2725 HWTEST_F_L0(BuiltinsMathTest, Max_3)
2726 {
2727 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("100");
2728 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2729 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2730 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2731 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
2732 ecmaRuntimeCallInfo->SetCallArg(1, test.GetTaggedValue());
2733 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(-101.5));
2734
2735 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2736 JSTaggedValue result = BuiltinsMath::Max(ecmaRuntimeCallInfo);
2737 TestHelper::TearDownFrame(thread_, prev);
2738 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(100.0);
2739 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2740 }
2741
2742 // Math.Max(-3,"-100",true)
HWTEST_F_L0(BuiltinsMathTest,Max_4)2743 HWTEST_F_L0(BuiltinsMathTest, Max_4)
2744 {
2745 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-100");
2746 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2747 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2748 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2749 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
2750 ecmaRuntimeCallInfo->SetCallArg(1, test.GetTaggedValue());
2751 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue::True());
2752
2753 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2754 JSTaggedValue result = BuiltinsMath::Max(ecmaRuntimeCallInfo);
2755 TestHelper::TearDownFrame(thread_, prev);
2756 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(1);
2757 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2758 }
2759
2760 // Math.min(NaN,1,POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Min)2761 HWTEST_F_L0(BuiltinsMathTest, Min)
2762 {
2763 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2764 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2765 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2766 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::NAN_VALUE));
2767 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
2768 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(base::POSITIVE_INFINITY));
2769
2770 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2771 JSTaggedValue result = BuiltinsMath::Min(ecmaRuntimeCallInfo);
2772 TestHelper::TearDownFrame(thread_, prev);
2773 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2774 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2775 }
2776
2777 // Math.min()
HWTEST_F_L0(BuiltinsMathTest,Min_1)2778 HWTEST_F_L0(BuiltinsMathTest, Min_1)
2779 {
2780 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
2781 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2782 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2783
2784 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2785 JSTaggedValue result = BuiltinsMath::Min(ecmaRuntimeCallInfo);
2786 TestHelper::TearDownFrame(thread_, prev);
2787 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2788 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2789 }
2790
2791 // Math.min("3",100,2.5)
HWTEST_F_L0(BuiltinsMathTest,Min_2)2792 HWTEST_F_L0(BuiltinsMathTest, Min_2)
2793 {
2794 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("3");
2795 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2796 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2797 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2798 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
2799 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(100)));
2800 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(2.5));
2801
2802 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2803 JSTaggedValue result = BuiltinsMath::Min(ecmaRuntimeCallInfo);
2804 TestHelper::TearDownFrame(thread_, prev);
2805 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(2.5);
2806 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2807 }
2808
2809 // Math.min(3,"100",-101.5)
HWTEST_F_L0(BuiltinsMathTest,Min_3)2810 HWTEST_F_L0(BuiltinsMathTest, Min_3)
2811 {
2812 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("100");
2813 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2814 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2815 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2816 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
2817 ecmaRuntimeCallInfo->SetCallArg(1, test.GetTaggedValue());
2818 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(-101.5));
2819
2820 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2821 JSTaggedValue result = BuiltinsMath::Min(ecmaRuntimeCallInfo);
2822 TestHelper::TearDownFrame(thread_, prev);
2823 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-101.5);
2824 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2825 }
2826
2827 // Math.min(3,100,false)
HWTEST_F_L0(BuiltinsMathTest,Min_4)2828 HWTEST_F_L0(BuiltinsMathTest, Min_4)
2829 {
2830 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 10);
2831 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2832 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2833 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
2834 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(100)));
2835 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue::False());
2836
2837 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2838 JSTaggedValue result = BuiltinsMath::Min(ecmaRuntimeCallInfo);
2839 TestHelper::TearDownFrame(thread_, prev);
2840 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(0);
2841 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2842 }
2843
2844 // Math.pow(2,"-2")
HWTEST_F_L0(BuiltinsMathTest,Pow)2845 HWTEST_F_L0(BuiltinsMathTest, Pow)
2846 {
2847 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-2");
2848 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
2849 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2850 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2851 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
2852 ecmaRuntimeCallInfo->SetCallArg(1, test.GetTaggedValue());
2853
2854 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2855 JSTaggedValue result = BuiltinsMath::Pow(ecmaRuntimeCallInfo);
2856 TestHelper::TearDownFrame(thread_, prev);
2857 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.25);
2858 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2859 }
2860
2861 // Math.pow(-NaN,-2)
HWTEST_F_L0(BuiltinsMathTest,Pow_1)2862 HWTEST_F_L0(BuiltinsMathTest, Pow_1)
2863 {
2864 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
2865 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2866 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2867 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2868 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
2869
2870 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2871 JSTaggedValue result = BuiltinsMath::Pow(ecmaRuntimeCallInfo);
2872 TestHelper::TearDownFrame(thread_, prev);
2873 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2874 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2875 }
2876
2877 // Math.pow()
HWTEST_F_L0(BuiltinsMathTest,Pow_2)2878 HWTEST_F_L0(BuiltinsMathTest, Pow_2)
2879 {
2880 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
2881 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2882 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2883
2884 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2885 JSTaggedValue result = BuiltinsMath::Pow(ecmaRuntimeCallInfo);
2886 TestHelper::TearDownFrame(thread_, prev);
2887 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2888 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2889 }
2890
2891 // Math.pow(false,-2)
HWTEST_F_L0(BuiltinsMathTest,Pow_3)2892 HWTEST_F_L0(BuiltinsMathTest, Pow_3)
2893 {
2894 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
2895 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2896 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2897 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::False());
2898 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
2899
2900 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2901 JSTaggedValue result = BuiltinsMath::Pow(ecmaRuntimeCallInfo);
2902 TestHelper::TearDownFrame(thread_, prev);
2903 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
2904 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2905 }
2906
2907 // Math.random()
HWTEST_F_L0(BuiltinsMathTest,Random)2908 HWTEST_F_L0(BuiltinsMathTest, Random)
2909 {
2910 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
2911 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2912 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2913
2914 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2915 JSTaggedValue result1 = BuiltinsMath::Random(ecmaRuntimeCallInfo);
2916 TestHelper::TearDownFrame(thread_, prev);
2917 double value1 = JSTaggedValue(static_cast<JSTaggedType>(result1.GetRawData())).GetDouble();
2918 ASSERT_TRUE(value1 >= 0);
2919 ASSERT_TRUE(value1 < 1.0);
2920 }
2921
2922 // Math.random()
HWTEST_F_L0(BuiltinsMathTest,Random_1)2923 HWTEST_F_L0(BuiltinsMathTest, Random_1)
2924 {
2925 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
2926 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2927 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2928
2929 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2930 JSTaggedValue result1 = BuiltinsMath::Random(ecmaRuntimeCallInfo);
2931 TestHelper::TearDownFrame(thread_, prev);
2932 JSTaggedValue result2 = BuiltinsMath::Random(ecmaRuntimeCallInfo);
2933 TestHelper::TearDownFrame(thread_, prev);
2934 double value1 = JSTaggedValue(static_cast<JSTaggedType>(result1.GetRawData())).GetDouble();
2935 double value2 = JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())).GetDouble();
2936 ASSERT_TRUE(value1 >= 0);
2937 ASSERT_TRUE(value1 < 1.0);
2938 ASSERT_TRUE(value2 >= 0);
2939 ASSERT_TRUE(value2 < 1.0);
2940 }
2941
2942 // Math.round(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Round)2943 HWTEST_F_L0(BuiltinsMathTest, Round)
2944 {
2945 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2946 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2947 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2948 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
2949
2950 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2951 JSTaggedValue result = BuiltinsMath::Round(ecmaRuntimeCallInfo);
2952 TestHelper::TearDownFrame(thread_, prev);
2953 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
2954 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2955 }
2956
2957 // Math.round(1.25)
HWTEST_F_L0(BuiltinsMathTest,Round_1)2958 HWTEST_F_L0(BuiltinsMathTest, Round_1)
2959 {
2960 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2961 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2962 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2963 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(1.25));
2964
2965 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2966 JSTaggedValue result = BuiltinsMath::Round(ecmaRuntimeCallInfo);
2967 TestHelper::TearDownFrame(thread_, prev);
2968 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
2969 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2970 }
2971
2972 // Math.round(-0.14)
HWTEST_F_L0(BuiltinsMathTest,Round_2)2973 HWTEST_F_L0(BuiltinsMathTest, Round_2)
2974 {
2975 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2976 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2977 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2978 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.14));
2979
2980 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2981 JSTaggedValue result = BuiltinsMath::Round(ecmaRuntimeCallInfo);
2982 TestHelper::TearDownFrame(thread_, prev);
2983 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
2984 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
2985 }
2986
2987 // Math.round(-0.7)
HWTEST_F_L0(BuiltinsMathTest,Round_3)2988 HWTEST_F_L0(BuiltinsMathTest, Round_3)
2989 {
2990 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
2991 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
2992 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
2993 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.7));
2994
2995 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
2996 JSTaggedValue result = BuiltinsMath::Round(ecmaRuntimeCallInfo);
2997 TestHelper::TearDownFrame(thread_, prev);
2998 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.0);
2999 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3000 }
3001
3002 // Math.round(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Round_4)3003 HWTEST_F_L0(BuiltinsMathTest, Round_4)
3004 {
3005 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3006 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3007 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3008 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3009
3010 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3011 JSTaggedValue result = BuiltinsMath::Round(ecmaRuntimeCallInfo);
3012 TestHelper::TearDownFrame(thread_, prev);
3013 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
3014 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3015 }
3016
3017 // Math.fround(POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Fround)3018 HWTEST_F_L0(BuiltinsMathTest, Fround)
3019 {
3020 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3021 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3022 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3023 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3024
3025 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3026 JSTaggedValue result = BuiltinsMath::Fround(ecmaRuntimeCallInfo);
3027 TestHelper::TearDownFrame(thread_, prev);
3028 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
3029 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3030 }
3031
3032 // Math.fround(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Fround_1)3033 HWTEST_F_L0(BuiltinsMathTest, Fround_1)
3034 {
3035 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3036 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3037 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3038 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3039
3040 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3041 JSTaggedValue result = BuiltinsMath::Fround(ecmaRuntimeCallInfo);
3042 TestHelper::TearDownFrame(thread_, prev);
3043 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3044 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3045 }
3046
3047 // Math.fround(-0)
HWTEST_F_L0(BuiltinsMathTest,Fround_2)3048 HWTEST_F_L0(BuiltinsMathTest, Fround_2)
3049 {
3050 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3051 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3052 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3053 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
3054
3055 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3056 JSTaggedValue result = BuiltinsMath::Fround(ecmaRuntimeCallInfo);
3057 TestHelper::TearDownFrame(thread_, prev);
3058 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
3059 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3060 }
3061
3062 // Math.fround(1.337)
HWTEST_F_L0(BuiltinsMathTest,Fround_3)3063 HWTEST_F_L0(BuiltinsMathTest, Fround_3)
3064 {
3065 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3066 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3067 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3068 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(1.337));
3069
3070 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3071 JSTaggedValue result = BuiltinsMath::Fround(ecmaRuntimeCallInfo);
3072 TestHelper::TearDownFrame(thread_, prev);
3073 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.3370000123977661);
3074 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3075 }
3076
3077 // Math.fround(-668523145.253485)
HWTEST_F_L0(BuiltinsMathTest,Fround_4)3078 HWTEST_F_L0(BuiltinsMathTest, Fround_4)
3079 {
3080 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3081 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3082 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3083 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-668523145.253485));
3084
3085 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3086 JSTaggedValue result = BuiltinsMath::Fround(ecmaRuntimeCallInfo);
3087 TestHelper::TearDownFrame(thread_, prev);
3088 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-668523136.0);
3089 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3090 }
3091
3092 // Math.clz32(NaN)
HWTEST_F_L0(BuiltinsMathTest,Clz32)3093 HWTEST_F_L0(BuiltinsMathTest, Clz32)
3094 {
3095 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3096 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3097 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3098 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3099
3100 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3101 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3102 TestHelper::TearDownFrame(thread_, prev);
3103 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(32);
3104 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3105 }
3106
3107 // Math.clz32(-0)
HWTEST_F_L0(BuiltinsMathTest,Clz32_1)3108 HWTEST_F_L0(BuiltinsMathTest, Clz32_1)
3109 {
3110 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3111 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3112 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3113 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
3114
3115 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3116 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3117 TestHelper::TearDownFrame(thread_, prev);
3118 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(32);
3119 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3120 }
3121
3122 // Math.clz32(1)
HWTEST_F_L0(BuiltinsMathTest,Clz32_2)3123 HWTEST_F_L0(BuiltinsMathTest, Clz32_2)
3124 {
3125 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3126 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3127 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3128 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
3129
3130 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3131 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3132 TestHelper::TearDownFrame(thread_, prev);
3133 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(31);
3134 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3135 }
3136
3137 // Math.clz32(568243)
HWTEST_F_L0(BuiltinsMathTest,Clz32_3)3138 HWTEST_F_L0(BuiltinsMathTest, Clz32_3)
3139 {
3140 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3141 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3142 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3143 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(568243)));
3144
3145 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3146 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3147 TestHelper::TearDownFrame(thread_, prev);
3148 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(12);
3149 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3150 }
3151
3152 // Math.clz32(4294967295)
HWTEST_F_L0(BuiltinsMathTest,Clz32_4)3153 HWTEST_F_L0(BuiltinsMathTest, Clz32_4)
3154 {
3155 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3156 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3157 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3158 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4294967295)));
3159
3160 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3161 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3162 TestHelper::TearDownFrame(thread_, prev);
3163 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(0);
3164 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3165 }
3166
3167 // Math.clz32(10000000000.123)
HWTEST_F_L0(BuiltinsMathTest,Clz32_5)3168 HWTEST_F_L0(BuiltinsMathTest, Clz32_5)
3169 {
3170 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3171 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3172 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3173 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(10000000000.123));
3174
3175 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3176 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3177 TestHelper::TearDownFrame(thread_, prev);
3178 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(1);
3179 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3180 }
3181
3182 // Math.clz32()
HWTEST_F_L0(BuiltinsMathTest,Clz32_6)3183 HWTEST_F_L0(BuiltinsMathTest, Clz32_6)
3184 {
3185 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
3186 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3187 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3188
3189 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3190 JSTaggedValue result = BuiltinsMath::Clz32(ecmaRuntimeCallInfo);
3191 TestHelper::TearDownFrame(thread_, prev);
3192 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(32);
3193 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3194 }
3195
3196 // Math.hypot()
HWTEST_F_L0(BuiltinsMathTest,Hypot)3197 HWTEST_F_L0(BuiltinsMathTest, Hypot)
3198 {
3199 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
3200 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3201 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3202
3203 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3204 JSTaggedValue result = BuiltinsMath::Hypot(ecmaRuntimeCallInfo);
3205 TestHelper::TearDownFrame(thread_, prev);
3206 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3207 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3208 }
3209
3210 // Math.hypot(-2.1)
HWTEST_F_L0(BuiltinsMathTest,Hypot_1)3211 HWTEST_F_L0(BuiltinsMathTest, Hypot_1)
3212 {
3213 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3214 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3215 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3216 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-2.1));
3217
3218 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3219 JSTaggedValue result = BuiltinsMath::Hypot(ecmaRuntimeCallInfo);
3220 TestHelper::TearDownFrame(thread_, prev);
3221 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(2.1);
3222 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3223 }
3224
3225 // Math.hypot(-NaN, 1)
HWTEST_F_L0(BuiltinsMathTest,Hypot_2)3226 HWTEST_F_L0(BuiltinsMathTest, Hypot_2)
3227 {
3228 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3229 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3230 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3231 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3232
3233 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3234 JSTaggedValue result = BuiltinsMath::Hypot(ecmaRuntimeCallInfo);
3235 TestHelper::TearDownFrame(thread_, prev);
3236 ASSERT_TRUE(result.IsDouble());
3237 ASSERT_TRUE(std::isnan(result.GetDouble()));
3238 }
3239
3240 // Math.hypot(true, 5, 8, -0.2, 90000)
HWTEST_F_L0(BuiltinsMathTest,Hypot_3)3241 HWTEST_F_L0(BuiltinsMathTest, Hypot_3)
3242 {
3243 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 14);
3244 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3245 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3246 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3247 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
3248 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(8)));
3249 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(-0.2));
3250 ecmaRuntimeCallInfo->SetCallArg(4, JSTaggedValue(static_cast<int32_t>(90000)));
3251
3252 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3253 JSTaggedValue result = BuiltinsMath::Hypot(ecmaRuntimeCallInfo);
3254 TestHelper::TearDownFrame(thread_, prev);
3255 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(90000.00050022222);
3256 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3257 }
3258
3259 // Math.Imul()
HWTEST_F_L0(BuiltinsMathTest,Imul)3260 HWTEST_F_L0(BuiltinsMathTest, Imul)
3261 {
3262 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 4);
3263 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3264 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3265
3266 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3267 JSTaggedValue result = BuiltinsMath::Imul(ecmaRuntimeCallInfo);
3268 TestHelper::TearDownFrame(thread_, prev);
3269 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(0);
3270 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3271 }
3272
3273 // Math.Imul("-2",9.256)
HWTEST_F_L0(BuiltinsMathTest,Imul_1)3274 HWTEST_F_L0(BuiltinsMathTest, Imul_1)
3275 {
3276 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-2");
3277 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
3278 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3279 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3280 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3281 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(9.256));
3282
3283 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3284 JSTaggedValue result = BuiltinsMath::Imul(ecmaRuntimeCallInfo);
3285 TestHelper::TearDownFrame(thread_, prev);
3286 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(-18);
3287 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3288 }
3289
3290 // Math.Imul(5,0xffffffff)
HWTEST_F_L0(BuiltinsMathTest,Imul_2)3291 HWTEST_F_L0(BuiltinsMathTest, Imul_2)
3292 {
3293 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
3294 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3295 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3296 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(5)));
3297 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0xffffffff)));
3298
3299 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3300 JSTaggedValue result = BuiltinsMath::Imul(ecmaRuntimeCallInfo);
3301 TestHelper::TearDownFrame(thread_, prev);
3302 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(-5);
3303 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3304 }
3305
3306 // Math.Imul(5,0xfffffffe)
HWTEST_F_L0(BuiltinsMathTest,Imul_3)3307 HWTEST_F_L0(BuiltinsMathTest, Imul_3)
3308 {
3309 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 8);
3310 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3311 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3312 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(5)));
3313 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0xfffffffe)));
3314
3315 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3316 JSTaggedValue result = BuiltinsMath::Imul(ecmaRuntimeCallInfo);
3317 TestHelper::TearDownFrame(thread_, prev);
3318 JSTaggedValue expect = BuiltinsBase::GetTaggedInt(-10);
3319 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3320 }
3321
3322 // Math.sin(-1)
HWTEST_F_L0(BuiltinsMathTest,Sin)3323 HWTEST_F_L0(BuiltinsMathTest, Sin)
3324 {
3325 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3326 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3327 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3328 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
3329
3330 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3331 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3332 TestHelper::TearDownFrame(thread_, prev);
3333 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.8414709848078965);
3334 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3335 }
3336
3337 // Math.sin(-1.5)
HWTEST_F_L0(BuiltinsMathTest,Sin_2)3338 HWTEST_F_L0(BuiltinsMathTest, Sin_2)
3339 {
3340 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3341 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3342 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3343 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-1.5));
3344
3345 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3346 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3347 TestHelper::TearDownFrame(thread_, prev);
3348 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.9974949866040544);
3349 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3350 }
3351
3352 // Math.sin(null)
HWTEST_F_L0(BuiltinsMathTest,Sin_3)3353 HWTEST_F_L0(BuiltinsMathTest, Sin_3)
3354 {
3355 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3356 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3357 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3358 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
3359
3360 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3361 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3362 TestHelper::TearDownFrame(thread_, prev);
3363 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3364 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3365 }
3366
3367 // Math.sin(UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Sin_4)3368 HWTEST_F_L0(BuiltinsMathTest, Sin_4)
3369 {
3370 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3371 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3372 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3373 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
3374
3375 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3376 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3377 TestHelper::TearDownFrame(thread_, prev);
3378 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3379 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3380 }
3381
3382 // Math.sin(true)
HWTEST_F_L0(BuiltinsMathTest,Sin_5)3383 HWTEST_F_L0(BuiltinsMathTest, Sin_5)
3384 {
3385 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3386 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3387 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3388 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3389
3390 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3391 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3392 TestHelper::TearDownFrame(thread_, prev);
3393 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.8414709848078965);
3394 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3395 }
3396
3397 // Math.sin("0.1")
HWTEST_F_L0(BuiltinsMathTest,Sin_6)3398 HWTEST_F_L0(BuiltinsMathTest, Sin_6)
3399 {
3400 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.1");
3401 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3402 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3403 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3404 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3405
3406 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3407 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3408 TestHelper::TearDownFrame(thread_, prev);
3409 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.09983341664682815);
3410 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3411 }
3412
3413 // Math.sin(Number.POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Sin_7)3414 HWTEST_F_L0(BuiltinsMathTest, Sin_7)
3415 {
3416 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3417 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3418 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3419 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3420
3421 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3422 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3423 TestHelper::TearDownFrame(thread_, prev);
3424 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3425 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3426 }
3427
3428 // Math.sin(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Sin_8)3429 HWTEST_F_L0(BuiltinsMathTest, Sin_8)
3430 {
3431 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3432 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3433 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3434 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3435
3436 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3437 JSTaggedValue result = BuiltinsMath::Sin(ecmaRuntimeCallInfo);
3438 TestHelper::TearDownFrame(thread_, prev);
3439 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3440 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3441 }
3442
3443 // Math.sinh(-1)
HWTEST_F_L0(BuiltinsMathTest,Sinh)3444 HWTEST_F_L0(BuiltinsMathTest, Sinh)
3445 {
3446 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3447 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3448 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3449 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
3450
3451 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3452 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3453 TestHelper::TearDownFrame(thread_, prev);
3454 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.1752011936438014);
3455 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3456 }
3457
3458 // Math.sinh(-1.5)
HWTEST_F_L0(BuiltinsMathTest,Sinh_1)3459 HWTEST_F_L0(BuiltinsMathTest, Sinh_1)
3460 {
3461 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3462 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3463 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3464 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-1.5));
3465
3466 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3467 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3468 TestHelper::TearDownFrame(thread_, prev);
3469 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-2.1292794550948173);
3470 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3471 }
3472
3473 // Math.sinh(null)
HWTEST_F_L0(BuiltinsMathTest,Sinh_2)3474 HWTEST_F_L0(BuiltinsMathTest, Sinh_2)
3475 {
3476 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3477 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3478 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3479 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
3480
3481 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3482 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3483 TestHelper::TearDownFrame(thread_, prev);
3484 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3485 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3486 }
3487
3488 // Math.sinh(UNDEFINED)
HWTEST_F_L0(BuiltinsMathTest,Sinh_3)3489 HWTEST_F_L0(BuiltinsMathTest, Sinh_3)
3490 {
3491 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3492 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3493 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3494 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
3495
3496 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3497 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3498 TestHelper::TearDownFrame(thread_, prev);
3499 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3500 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3501 }
3502
3503 // Math.sinh(true)
HWTEST_F_L0(BuiltinsMathTest,Sinh_4)3504 HWTEST_F_L0(BuiltinsMathTest, Sinh_4)
3505 {
3506 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3507 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3508 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3509 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3510
3511 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3512 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3513 TestHelper::TearDownFrame(thread_, prev);
3514 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.1752011936438014);
3515 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3516 }
3517
3518 // Math.sinh("0.1")
HWTEST_F_L0(BuiltinsMathTest,Sinh_5)3519 HWTEST_F_L0(BuiltinsMathTest, Sinh_5)
3520 {
3521 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.1");
3522 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3523 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3524 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3525 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3526
3527 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3528 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3529 TestHelper::TearDownFrame(thread_, prev);
3530 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.10016675001984403);
3531 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3532 }
3533
3534 // Math.sinh(-Number.POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Sinh_6)3535 HWTEST_F_L0(BuiltinsMathTest, Sinh_6)
3536 {
3537 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3538 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3539 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3540 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::POSITIVE_INFINITY));
3541
3542 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3543 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3544 TestHelper::TearDownFrame(thread_, prev);
3545 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-base::POSITIVE_INFINITY);
3546 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3547 }
3548
3549 // Math.sinh(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Sinh_7)3550 HWTEST_F_L0(BuiltinsMathTest, Sinh_7)
3551 {
3552 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3553 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3554 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3555 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3556
3557 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3558 JSTaggedValue result = BuiltinsMath::Sinh(ecmaRuntimeCallInfo);
3559 TestHelper::TearDownFrame(thread_, prev);
3560 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3561 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3562 }
3563
3564 // Math.sqrt(-1)
HWTEST_F_L0(BuiltinsMathTest,Sqrt)3565 HWTEST_F_L0(BuiltinsMathTest, Sqrt)
3566 {
3567 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3568 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3569 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3570 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
3571
3572 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3573 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3574 TestHelper::TearDownFrame(thread_, prev);
3575 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3576 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3577 }
3578
3579 // Math.sqrt(-0)
HWTEST_F_L0(BuiltinsMathTest,Sqrt_1)3580 HWTEST_F_L0(BuiltinsMathTest, Sqrt_1)
3581 {
3582 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3583 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3584 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3585 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
3586
3587 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3588 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3589 TestHelper::TearDownFrame(thread_, prev);
3590 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
3591 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3592 }
3593
3594 // Math.sqrt(null)
HWTEST_F_L0(BuiltinsMathTest,Sqrt_2)3595 HWTEST_F_L0(BuiltinsMathTest, Sqrt_2)
3596 {
3597 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3598 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3599 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3600 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
3601
3602 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3603 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3604 TestHelper::TearDownFrame(thread_, prev);
3605 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3606 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3607 }
3608
3609 // Math.sqrt(true)
HWTEST_F_L0(BuiltinsMathTest,Sqrt_3)3610 HWTEST_F_L0(BuiltinsMathTest, Sqrt_3)
3611 {
3612 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3613 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3614 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3615 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3616
3617 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3618 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3619 TestHelper::TearDownFrame(thread_, prev);
3620 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
3621 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3622 }
3623
3624 // Math.sqrt("0.1")
HWTEST_F_L0(BuiltinsMathTest,Sqrt_4)3625 HWTEST_F_L0(BuiltinsMathTest, Sqrt_4)
3626 {
3627 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.1");
3628 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3629 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3630 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3631 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3632
3633 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3634 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3635 TestHelper::TearDownFrame(thread_, prev);
3636 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.31622776601683794);
3637 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3638 }
3639
3640 // Math.sqrt(Number.POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Sqrt_5)3641 HWTEST_F_L0(BuiltinsMathTest, Sqrt_5)
3642 {
3643 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3644 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3645 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3646 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3647
3648 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3649 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3650 TestHelper::TearDownFrame(thread_, prev);
3651 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
3652 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3653 }
3654
3655 // Math.sqrt(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Sqrt_6)3656 HWTEST_F_L0(BuiltinsMathTest, Sqrt_6)
3657 {
3658 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3659 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3660 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3661 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-base::NAN_VALUE)));
3662
3663 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3664 JSTaggedValue result = BuiltinsMath::Sqrt(ecmaRuntimeCallInfo);
3665 TestHelper::TearDownFrame(thread_, prev);
3666 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3667 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3668 }
3669
3670 // Math.tan(-1)
HWTEST_F_L0(BuiltinsMathTest,Tan)3671 HWTEST_F_L0(BuiltinsMathTest, Tan)
3672 {
3673 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3674 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3675 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3676 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
3677
3678 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3679 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3680 TestHelper::TearDownFrame(thread_, prev);
3681 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.5574077246549023);
3682 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3683 }
3684
3685 // Math.tan(-0)
HWTEST_F_L0(BuiltinsMathTest,Tan_1)3686 HWTEST_F_L0(BuiltinsMathTest, Tan_1)
3687 {
3688 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3689 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3690 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3691 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
3692
3693 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3694 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3695 TestHelper::TearDownFrame(thread_, prev);
3696 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
3697 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3698 }
3699
3700 // Math.tan(null)
HWTEST_F_L0(BuiltinsMathTest,Tan_2)3701 HWTEST_F_L0(BuiltinsMathTest, Tan_2)
3702 {
3703 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3704 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3705 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3706 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
3707
3708 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3709 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3710 TestHelper::TearDownFrame(thread_, prev);
3711 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3712 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3713 }
3714
3715 // Math.tan(true)
HWTEST_F_L0(BuiltinsMathTest,Tan_3)3716 HWTEST_F_L0(BuiltinsMathTest, Tan_3)
3717 {
3718 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3719 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3720 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3721 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3722
3723 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3724 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3725 TestHelper::TearDownFrame(thread_, prev);
3726 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.5574077246549023);
3727 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3728 }
3729
3730 // Math.tan("0.1")
HWTEST_F_L0(BuiltinsMathTest,Tan_4)3731 HWTEST_F_L0(BuiltinsMathTest, Tan_4)
3732 {
3733 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.1");
3734 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3735 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3736 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3737 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3738
3739 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3740 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3741 TestHelper::TearDownFrame(thread_, prev);
3742 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.10033467208545055);
3743 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3744 }
3745
3746 // Math.tan(Number.POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Tan_5)3747 HWTEST_F_L0(BuiltinsMathTest, Tan_5)
3748 {
3749 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3750 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3751 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3752 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3753
3754 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3755 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3756 TestHelper::TearDownFrame(thread_, prev);
3757 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3758 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3759 }
3760
3761 // Math.tan(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Tan_6)3762 HWTEST_F_L0(BuiltinsMathTest, Tan_6)
3763 {
3764 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3765 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3766 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3767 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3768
3769 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3770 JSTaggedValue result = BuiltinsMath::Tan(ecmaRuntimeCallInfo);
3771 TestHelper::TearDownFrame(thread_, prev);
3772 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3773 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3774 }
3775
3776 // Math.tanh(-1)
HWTEST_F_L0(BuiltinsMathTest,Tanh)3777 HWTEST_F_L0(BuiltinsMathTest, Tanh)
3778 {
3779 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3780 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3781 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3782 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
3783
3784 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3785 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3786 TestHelper::TearDownFrame(thread_, prev);
3787 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.7615941559557649);
3788 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3789 }
3790
3791 // Math.tanh(-0)
HWTEST_F_L0(BuiltinsMathTest,Tanh_1)3792 HWTEST_F_L0(BuiltinsMathTest, Tanh_1)
3793 {
3794 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3795 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3796 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3797 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
3798
3799 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3800 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3801 TestHelper::TearDownFrame(thread_, prev);
3802 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
3803 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3804 }
3805
3806 // Math.tanh(null)
HWTEST_F_L0(BuiltinsMathTest,Tanh_2)3807 HWTEST_F_L0(BuiltinsMathTest, Tanh_2)
3808 {
3809 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3810 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3811 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3812 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
3813
3814 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3815 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3816 TestHelper::TearDownFrame(thread_, prev);
3817 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3818 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3819 }
3820
3821 // Math.tanh(true)
HWTEST_F_L0(BuiltinsMathTest,Tanh_3)3822 HWTEST_F_L0(BuiltinsMathTest, Tanh_3)
3823 {
3824 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3825 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3826 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3827 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3828
3829 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3830 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3831 TestHelper::TearDownFrame(thread_, prev);
3832 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.7615941559557649);
3833 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3834 }
3835
3836 // Math.tanh("0.1")
HWTEST_F_L0(BuiltinsMathTest,Tanh_4)3837 HWTEST_F_L0(BuiltinsMathTest, Tanh_4)
3838 {
3839 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("0.1");
3840 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3841 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3842 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3843 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3844
3845 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3846 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3847 TestHelper::TearDownFrame(thread_, prev);
3848 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0.09966799462495582);
3849 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3850 }
3851
3852 // Math.tanh(Number.POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Tanh_5)3853 HWTEST_F_L0(BuiltinsMathTest, Tanh_5)
3854 {
3855 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3856 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3857 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3858 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3859
3860 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3861 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3862 TestHelper::TearDownFrame(thread_, prev);
3863 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
3864 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3865 }
3866
3867 // Math.tanh(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Tanh_6)3868 HWTEST_F_L0(BuiltinsMathTest, Tanh_6)
3869 {
3870 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3871 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3872 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3873 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3874
3875 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3876 JSTaggedValue result = BuiltinsMath::Tanh(ecmaRuntimeCallInfo);
3877 TestHelper::TearDownFrame(thread_, prev);
3878 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3879 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3880 }
3881
3882 // Math.trunc(-1)
HWTEST_F_L0(BuiltinsMathTest,Trunc)3883 HWTEST_F_L0(BuiltinsMathTest, Trunc)
3884 {
3885 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3886 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3887 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3888 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
3889
3890 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3891 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3892 TestHelper::TearDownFrame(thread_, prev);
3893 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-1.0);
3894 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3895 }
3896
3897 // Math.trunc(-0)
HWTEST_F_L0(BuiltinsMathTest,Trunc_1)3898 HWTEST_F_L0(BuiltinsMathTest, Trunc_1)
3899 {
3900 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3901 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3902 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3903 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-0.0));
3904
3905 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3906 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3907 TestHelper::TearDownFrame(thread_, prev);
3908 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
3909 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3910 }
3911
3912 // Math.trunc(null)
HWTEST_F_L0(BuiltinsMathTest,Trunc_2)3913 HWTEST_F_L0(BuiltinsMathTest, Trunc_2)
3914 {
3915 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3916 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3917 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3918 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Null());
3919
3920 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3921 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3922 TestHelper::TearDownFrame(thread_, prev);
3923 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(0);
3924 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3925 }
3926
3927 // Math.trunc(true)
HWTEST_F_L0(BuiltinsMathTest,Trunc_3)3928 HWTEST_F_L0(BuiltinsMathTest, Trunc_3)
3929 {
3930 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3931 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3932 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3933 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::True());
3934
3935 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3936 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3937 TestHelper::TearDownFrame(thread_, prev);
3938 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(1.0);
3939 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3940 }
3941
3942 // Math.trunc("-0.1")
HWTEST_F_L0(BuiltinsMathTest,Trunc_4)3943 HWTEST_F_L0(BuiltinsMathTest, Trunc_4)
3944 {
3945 JSHandle<EcmaString> test = thread_->GetEcmaVM()->GetFactory()->NewFromASCII("-0.1");
3946 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3947 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3948 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3949 ecmaRuntimeCallInfo->SetCallArg(0, test.GetTaggedValue());
3950
3951 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3952 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3953 TestHelper::TearDownFrame(thread_, prev);
3954 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(-0.0);
3955 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3956 }
3957
3958 // Math.trunc(Number.POSITIVE_INFINITY)
HWTEST_F_L0(BuiltinsMathTest,Trunc_5)3959 HWTEST_F_L0(BuiltinsMathTest, Trunc_5)
3960 {
3961 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3962 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3963 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3964 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(base::POSITIVE_INFINITY));
3965
3966 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3967 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3968 TestHelper::TearDownFrame(thread_, prev);
3969 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::POSITIVE_INFINITY);
3970 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3971 }
3972
3973 // Math.trunc(-NaN)
HWTEST_F_L0(BuiltinsMathTest,Trunc_6)3974 HWTEST_F_L0(BuiltinsMathTest, Trunc_6)
3975 {
3976 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread_, JSTaggedValue::Undefined(), 6);
3977 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
3978 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
3979 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(-base::NAN_VALUE));
3980
3981 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread_, ecmaRuntimeCallInfo);
3982 JSTaggedValue result = BuiltinsMath::Trunc(ecmaRuntimeCallInfo);
3983 TestHelper::TearDownFrame(thread_, prev);
3984 JSTaggedValue expect = BuiltinsBase::GetTaggedDouble(base::NAN_VALUE);
3985 ASSERT_EQ(result.GetRawData(), expect.GetRawData());
3986 }
3987 } // namespace panda::test
3988