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_date.h"
17
18 #include "ecmascript/base/string_helper.h"
19 #include "ecmascript/ecma_vm.h"
20 #include "ecmascript/global_env.h"
21 #include "ecmascript/js_function.h"
22 #include "ecmascript/js_thread.h"
23 #include "ecmascript/platform/time.h"
24 #include "ecmascript/tests/test_helper.h"
25
26 using namespace panda::ecmascript;
27 using namespace panda::ecmascript::builtins;
28 namespace panda::test {
29 const char NEG = '-';
30 const char PLUS = '+';
31 const int STR_LENGTH_OTHERS = 2;
32 const int MINUTE_PER_HOUR = 60;
33 class BuiltinsDateTest : public testing::Test {
34 public:
SetUpTestCase()35 static void SetUpTestCase()
36 {
37 GTEST_LOG_(INFO) << "SetUpTestCase";
38 }
39
TearDownTestCase()40 static void TearDownTestCase()
41 {
42 GTEST_LOG_(INFO) << "TearDownCase";
43 }
44
SetUp()45 void SetUp() override
46 {
47 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
48 }
49
TearDown()50 void TearDown() override
51 {
52 TestHelper::DestroyEcmaVMWithScope(instance, scope);
53 }
54
55 EcmaVM *instance {nullptr};
56 EcmaHandleScope *scope {nullptr};
57 JSThread *thread {nullptr};
58 };
59
JSDateCreateTest(JSThread * thread)60 JSHandle<JSDate> JSDateCreateTest(JSThread *thread)
61 {
62 EcmaVM *ecmaVM = thread->GetEcmaVM();
63 ObjectFactory *factory = ecmaVM->GetFactory();
64 JSHandle<GlobalEnv> globalEnv = ecmaVM->GetGlobalEnv();
65 JSHandle<JSTaggedValue> dateFunction = globalEnv->GetDateFunction();
66 JSHandle<JSDate> dateObject =
67 JSHandle<JSDate>::Cast(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(dateFunction), dateFunction));
68 return dateObject;
69 }
70
HWTEST_F_L0(BuiltinsDateTest,SetGetDate)71 HWTEST_F_L0(BuiltinsDateTest, SetGetDate)
72 {
73 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
74
75 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
76 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
77 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
78 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2)));
79
80 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
81 [[maybe_unused]] JSTaggedValue result1 = BuiltinsDate::SetDate(ecmaRuntimeCallInfo);
82 JSTaggedValue result2 = BuiltinsDate::GetDate(ecmaRuntimeCallInfo);
83 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
84 }
85
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCDate)86 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCDate)
87 {
88 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
89
90 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
91 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
92 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
93 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2)));
94
95 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
96 [[maybe_unused]] JSTaggedValue result3 = BuiltinsDate::SetUTCDate(ecmaRuntimeCallInfo);
97 JSTaggedValue result4 = BuiltinsDate::GetUTCDate(ecmaRuntimeCallInfo);
98 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
99 }
100
HWTEST_F_L0(BuiltinsDateTest,SetGetMinusUTCDate)101 HWTEST_F_L0(BuiltinsDateTest, SetGetMinusUTCDate)
102 {
103 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
104
105 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
106 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
107 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
108 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-2)));
109
110 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
111 [[maybe_unused]] JSTaggedValue result3 = BuiltinsDate::SetUTCDate(ecmaRuntimeCallInfo);
112 JSTaggedValue result4 = BuiltinsDate::GetUTCDate(ecmaRuntimeCallInfo);
113 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(29)).GetRawData());
114 }
115
HWTEST_F_L0(BuiltinsDateTest,SetGetFullYear)116 HWTEST_F_L0(BuiltinsDateTest, SetGetFullYear)
117 {
118 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
119
120 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
121 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
122 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
123 // 2018 : test case
124 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
125 // 10 : test case
126 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
127 // 2, 6 : test case
128 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(6)));
129
130 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
131 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo);
132 JSTaggedValue result1 = BuiltinsDate::GetFullYear(ecmaRuntimeCallInfo);
133 // 2018 : test case
134 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(2018)).GetRawData());
135
136 JSTaggedValue result2 = BuiltinsDate::GetMonth(ecmaRuntimeCallInfo);
137 // 10 : test case
138 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
139
140 JSTaggedValue result3 = BuiltinsDate::GetDate(ecmaRuntimeCallInfo);
141 // 6 : test case
142 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(6)).GetRawData());
143 }
144
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCFullYear)145 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCFullYear)
146 {
147 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
148
149 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
150 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
151 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
152 // 2018 : test case
153 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
154 // 10 : test case
155 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
156 // 2, 6 : test case
157 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(6)));
158
159 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
160 BuiltinsDate::SetUTCFullYear(ecmaRuntimeCallInfo);
161 JSTaggedValue result4 = BuiltinsDate::GetUTCFullYear(ecmaRuntimeCallInfo);
162 // 2018 : test case
163 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(2018)).GetRawData());
164
165 JSTaggedValue result5 = BuiltinsDate::GetUTCMonth(ecmaRuntimeCallInfo);
166 // 10 : test case
167 ASSERT_EQ(result5.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
168
169 JSTaggedValue result6 = BuiltinsDate::GetUTCDate(ecmaRuntimeCallInfo);
170 // 6 : test case
171 ASSERT_EQ(result6.GetRawData(), JSTaggedValue(static_cast<double>(6)).GetRawData());
172 }
173
HWTEST_F_L0(BuiltinsDateTest,SetGetMinusFullYear)174 HWTEST_F_L0(BuiltinsDateTest, SetGetMinusFullYear)
175 {
176 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
177 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
178 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
179 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
180 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-2018)));
181 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(-10)));
182 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(-6)));
183
184 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
185 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo);
186 JSTaggedValue result1 = BuiltinsDate::GetFullYear(ecmaRuntimeCallInfo);
187 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(-2019)).GetRawData());
188
189 JSTaggedValue result2 = BuiltinsDate::GetMonth(ecmaRuntimeCallInfo);
190 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(1)).GetRawData());
191
192 JSTaggedValue result3 = BuiltinsDate::GetDate(ecmaRuntimeCallInfo);
193 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(22)).GetRawData());
194 }
195
HWTEST_F_L0(BuiltinsDateTest,SetGetMinusUTCFullYear)196 HWTEST_F_L0(BuiltinsDateTest, SetGetMinusUTCFullYear)
197 {
198 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
199
200 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
201 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
202 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
203 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-2018)));
204 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(-10)));
205 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(-6)));
206
207 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
208 BuiltinsDate::SetUTCFullYear(ecmaRuntimeCallInfo);
209 JSTaggedValue result4 = BuiltinsDate::GetUTCFullYear(ecmaRuntimeCallInfo);
210 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(-2019)).GetRawData());
211
212 JSTaggedValue result5 = BuiltinsDate::GetUTCMonth(ecmaRuntimeCallInfo);
213 ASSERT_EQ(result5.GetRawData(), JSTaggedValue(static_cast<double>(1)).GetRawData());
214
215 JSTaggedValue result6 = BuiltinsDate::GetUTCDate(ecmaRuntimeCallInfo);
216 ASSERT_EQ(result6.GetRawData(), JSTaggedValue(static_cast<double>(22)).GetRawData());
217 }
218
HWTEST_F_L0(BuiltinsDateTest,SetGetHours)219 HWTEST_F_L0(BuiltinsDateTest, SetGetHours)
220 {
221 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
222
223 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
224 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
225 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
226 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(18)));
227 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
228 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(6)));
229 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<double>(111)));
230
231 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
232 BuiltinsDate::SetHours(ecmaRuntimeCallInfo);
233 JSTaggedValue result1 = BuiltinsDate::GetHours(ecmaRuntimeCallInfo);
234 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(18)).GetRawData());
235
236 JSTaggedValue result2 = BuiltinsDate::GetMinutes(ecmaRuntimeCallInfo);
237 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
238
239 JSTaggedValue result3 = BuiltinsDate::GetSeconds(ecmaRuntimeCallInfo);
240 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(6)).GetRawData());
241
242 JSTaggedValue result4 = BuiltinsDate::GetMilliseconds(ecmaRuntimeCallInfo);
243 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(111)).GetRawData());
244 }
245
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCHours)246 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCHours)
247 {
248 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
249
250 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
251 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
252 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
253 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(18)));
254 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
255 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(6)));
256 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<double>(111)));
257
258 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
259 BuiltinsDate::SetUTCHours(ecmaRuntimeCallInfo);
260 JSTaggedValue result5 = BuiltinsDate::GetUTCHours(ecmaRuntimeCallInfo);
261 ASSERT_EQ(result5.GetRawData(), JSTaggedValue(static_cast<double>(18)).GetRawData());
262
263 JSTaggedValue result6 = BuiltinsDate::GetUTCMinutes(ecmaRuntimeCallInfo);
264 ASSERT_EQ(result6.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
265
266 JSTaggedValue result7 = BuiltinsDate::GetUTCSeconds(ecmaRuntimeCallInfo);
267 ASSERT_EQ(result7.GetRawData(), JSTaggedValue(static_cast<double>(6)).GetRawData());
268
269 JSTaggedValue result8 = BuiltinsDate::GetUTCMilliseconds(ecmaRuntimeCallInfo);
270 ASSERT_EQ(result8.GetRawData(), JSTaggedValue(static_cast<double>(111)).GetRawData());
271 }
272
HWTEST_F_L0(BuiltinsDateTest,SetGetMinusHours)273 HWTEST_F_L0(BuiltinsDateTest, SetGetMinusHours)
274 {
275 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
276
277 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
278 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
279 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
280 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-18)));
281 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(-10)));
282 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(-6)));
283 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<double>(-111)));
284
285 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
286 BuiltinsDate::SetHours(ecmaRuntimeCallInfo);
287 JSTaggedValue result1 = BuiltinsDate::GetHours(ecmaRuntimeCallInfo);
288 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
289
290 JSTaggedValue result2 = BuiltinsDate::GetMinutes(ecmaRuntimeCallInfo);
291 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(49)).GetRawData());
292
293 JSTaggedValue result3 = BuiltinsDate::GetSeconds(ecmaRuntimeCallInfo);
294 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(53)).GetRawData());
295
296 JSTaggedValue result4 = BuiltinsDate::GetMilliseconds(ecmaRuntimeCallInfo);
297 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(889)).GetRawData());
298 }
299
HWTEST_F_L0(BuiltinsDateTest,SetGetMinusUTCHours)300 HWTEST_F_L0(BuiltinsDateTest, SetGetMinusUTCHours)
301 {
302 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
303
304 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
305 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
306 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
307 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(-18)));
308 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(-10)));
309 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(-6)));
310 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<double>(-111)));
311
312 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
313 BuiltinsDate::SetUTCHours(ecmaRuntimeCallInfo);
314 JSTaggedValue result5 = BuiltinsDate::GetUTCHours(ecmaRuntimeCallInfo);
315 ASSERT_EQ(result5.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
316
317 JSTaggedValue result6 = BuiltinsDate::GetUTCMinutes(ecmaRuntimeCallInfo);
318 ASSERT_EQ(result6.GetRawData(), JSTaggedValue(static_cast<double>(49)).GetRawData());
319
320 JSTaggedValue result7 = BuiltinsDate::GetUTCSeconds(ecmaRuntimeCallInfo);
321 ASSERT_EQ(result7.GetRawData(), JSTaggedValue(static_cast<double>(53)).GetRawData());
322
323 JSTaggedValue result8 = BuiltinsDate::GetUTCMilliseconds(ecmaRuntimeCallInfo);
324 ASSERT_EQ(result8.GetRawData(), JSTaggedValue(static_cast<double>(889)).GetRawData());
325 }
326
HWTEST_F_L0(BuiltinsDateTest,SetGetMilliseconds)327 HWTEST_F_L0(BuiltinsDateTest, SetGetMilliseconds)
328 {
329 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
330
331 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
332 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
333 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
334 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(100)));
335
336 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
337 JSTaggedValue result1 = BuiltinsDate::SetMilliseconds(ecmaRuntimeCallInfo);
338 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(100)).GetRawData());
339
340 JSTaggedValue result2 = BuiltinsDate::GetMilliseconds(ecmaRuntimeCallInfo);
341 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(100)).GetRawData());
342 }
343
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCMilliseconds)344 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCMilliseconds)
345 {
346 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
347
348 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
349 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
350 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
351 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(100)));
352
353 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
354 JSTaggedValue result3 = BuiltinsDate::SetUTCMilliseconds(ecmaRuntimeCallInfo);
355 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(100)).GetRawData());
356
357 JSTaggedValue result4 = BuiltinsDate::GetUTCMilliseconds(ecmaRuntimeCallInfo);
358 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(100)).GetRawData());
359 }
360
HWTEST_F_L0(BuiltinsDateTest,SetGetMinutes)361 HWTEST_F_L0(BuiltinsDateTest, SetGetMinutes)
362 {
363 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
364
365 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
366 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
367 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
368 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(10)));
369 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(6)));
370 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(111)));
371
372 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
373 BuiltinsDate::SetMinutes(ecmaRuntimeCallInfo);
374 JSTaggedValue result1 = BuiltinsDate::GetMinutes(ecmaRuntimeCallInfo);
375 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
376
377 JSTaggedValue result2 = BuiltinsDate::GetSeconds(ecmaRuntimeCallInfo);
378 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(6)).GetRawData());
379
380 JSTaggedValue result3 = BuiltinsDate::GetMilliseconds(ecmaRuntimeCallInfo);
381 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(111)).GetRawData());
382 }
383
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCMinutes)384 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCMinutes)
385 {
386 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
387
388 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
389 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
390 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
391 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(10)));
392 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(6)));
393 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(111)));
394
395 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
396 BuiltinsDate::SetUTCMinutes(ecmaRuntimeCallInfo);
397 JSTaggedValue result4 = BuiltinsDate::GetUTCMinutes(ecmaRuntimeCallInfo);
398 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
399
400 JSTaggedValue result5 = BuiltinsDate::GetUTCSeconds(ecmaRuntimeCallInfo);
401 ASSERT_EQ(result5.GetRawData(), JSTaggedValue(static_cast<double>(6)).GetRawData());
402
403 JSTaggedValue result6 = BuiltinsDate::GetUTCMilliseconds(ecmaRuntimeCallInfo);
404 ASSERT_EQ(result6.GetRawData(), JSTaggedValue(static_cast<double>(111)).GetRawData());
405 }
406
HWTEST_F_L0(BuiltinsDateTest,SetGetMonth)407 HWTEST_F_L0(BuiltinsDateTest, SetGetMonth)
408 {
409 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
410
411 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
412 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
413 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
414 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(8)));
415 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(3)));
416
417 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
418 BuiltinsDate::SetMonth(ecmaRuntimeCallInfo);
419 JSTaggedValue result1 = BuiltinsDate::GetMonth(ecmaRuntimeCallInfo);
420 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(8)).GetRawData());
421
422 JSTaggedValue result2 = BuiltinsDate::GetDate(ecmaRuntimeCallInfo);
423 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(3)).GetRawData());
424 }
425
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCMonth)426 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCMonth)
427 {
428 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
429
430 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
431 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
432 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
433 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(8)));
434 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(3)));
435
436 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
437 BuiltinsDate::SetUTCMonth(ecmaRuntimeCallInfo);
438 JSTaggedValue result3 = BuiltinsDate::GetUTCMonth(ecmaRuntimeCallInfo);
439 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(8)).GetRawData());
440
441 JSTaggedValue result4 = BuiltinsDate::GetUTCDate(ecmaRuntimeCallInfo);
442 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(3)).GetRawData());
443 }
444
HWTEST_F_L0(BuiltinsDateTest,SetGetSeconds)445 HWTEST_F_L0(BuiltinsDateTest, SetGetSeconds)
446 {
447 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
448
449 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
450 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
451 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
452 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(59)));
453 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(123)));
454
455 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
456 BuiltinsDate::SetSeconds(ecmaRuntimeCallInfo);
457 JSTaggedValue result1 = BuiltinsDate::GetSeconds(ecmaRuntimeCallInfo);
458 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(59)).GetRawData());
459
460 JSTaggedValue result2 = BuiltinsDate::GetMilliseconds(ecmaRuntimeCallInfo);
461 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(123)).GetRawData());
462 }
463
HWTEST_F_L0(BuiltinsDateTest,SetGetUTCSeconds)464 HWTEST_F_L0(BuiltinsDateTest, SetGetUTCSeconds)
465 {
466 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
467
468 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
469 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
470 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
471 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(59)));
472 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(123)));
473
474 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
475 BuiltinsDate::SetUTCSeconds(ecmaRuntimeCallInfo);
476 JSTaggedValue result3 = BuiltinsDate::GetUTCSeconds(ecmaRuntimeCallInfo);
477 ASSERT_EQ(result3.GetRawData(), JSTaggedValue(static_cast<double>(59)).GetRawData());
478
479 JSTaggedValue result4 = BuiltinsDate::GetUTCMilliseconds(ecmaRuntimeCallInfo);
480 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(123)).GetRawData());
481 }
482
HWTEST_F_L0(BuiltinsDateTest,SetGetTime)483 HWTEST_F_L0(BuiltinsDateTest, SetGetTime)
484 {
485 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
486
487 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
488 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
489 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
490 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2)));
491
492 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
493 JSTaggedValue result = BuiltinsDate::SetTime(ecmaRuntimeCallInfo);
494 TestHelper::TearDownFrame(thread, prev);
495 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
496
497 result = BuiltinsDate::GetTime(ecmaRuntimeCallInfo);
498 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
499
500 // msg != IsDate
501 auto info1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
502 info1->SetFunction(JSTaggedValue::Undefined());
503 info1->SetThis(JSTaggedValue::Undefined());
504 info1->SetCallArg(0, JSTaggedValue(static_cast<double>(2)));
505
506 prev = TestHelper::SetupFrame(thread, info1);
507 result = BuiltinsDate::SetTime(info1);
508 TestHelper::TearDownFrame(thread, prev);
509 EXPECT_TRUE(thread->HasPendingException());
510 EXPECT_EQ(result, JSTaggedValue::Exception());
511 thread->ClearException();
512
513 auto info2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
514 info2->SetFunction(JSTaggedValue::Undefined());
515 info2->SetThis(JSTaggedValue::Undefined());
516 info2->SetCallArg(0, JSTaggedValue(static_cast<double>(2)));
517 result = BuiltinsDate::GetTime(info2);
518 TestHelper::TearDownFrame(thread, prev);
519 EXPECT_TRUE(thread->HasPendingException());
520 EXPECT_EQ(result, JSTaggedValue::Exception());
521 thread->ClearException();
522 }
523
HWTEST_F_L0(BuiltinsDateTest,UTC)524 HWTEST_F_L0(BuiltinsDateTest, UTC)
525 {
526 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
527 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
528 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
529 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(2020.982));
530 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(10.23));
531 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(4.32));
532 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(11.32));
533
534 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
535 JSTaggedValue result1 = BuiltinsDate::UTC(ecmaRuntimeCallInfo);
536 TestHelper::TearDownFrame(thread, prev);
537 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1604487600000)).GetRawData());
538
539 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 18);
540 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
541 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
542 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(2020.982));
543 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(10.23));
544 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(4.32));
545 ecmaRuntimeCallInfo1->SetCallArg(3, JSTaggedValue(11.32));
546 ecmaRuntimeCallInfo1->SetCallArg(4, JSTaggedValue(45.1));
547 ecmaRuntimeCallInfo1->SetCallArg(5, JSTaggedValue(34.321));
548 ecmaRuntimeCallInfo1->SetCallArg(6, JSTaggedValue(static_cast<int32_t>(231)));
549
550 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
551 result1 = BuiltinsDate::UTC(ecmaRuntimeCallInfo1);
552 TestHelper::TearDownFrame(thread, prev);
553 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1604490334231)).GetRawData());
554
555 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
556 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
557 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue::Undefined());
558 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(10.23));
559 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(4.32));
560 ecmaRuntimeCallInfo2->SetCallArg(2, JSTaggedValue(11.32));
561
562 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
563 result1 = BuiltinsDate::UTC(ecmaRuntimeCallInfo2);
564 TestHelper::TearDownFrame(thread, prev);
565 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(-1882224000000)).GetRawData());
566
567 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
568 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
569 ecmaRuntimeCallInfo3->SetThis(JSTaggedValue::Undefined());
570 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(1994.982));
571
572 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
573 result1 = BuiltinsDate::UTC(ecmaRuntimeCallInfo3);
574 TestHelper::TearDownFrame(thread, prev);
575 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(757382400000)).GetRawData());
576
577 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
578 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
579 ecmaRuntimeCallInfo4->SetThis(JSTaggedValue::Undefined());
580 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(19999944.982));
581
582 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
583 result1 = BuiltinsDate::UTC(ecmaRuntimeCallInfo4);
584 TestHelper::TearDownFrame(thread, prev);
585 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(base::NAN_VALUE)).GetRawData());
586 }
587
SetAllYearAndHours(JSThread * thread,const JSHandle<JSDate> & jsDate)588 void SetAllYearAndHours(JSThread *thread, const JSHandle<JSDate> &jsDate)
589 {
590 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
591 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
592 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
593 // 2018 : test case
594 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
595 // 10 : test case
596 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
597 // 2, 6 : test case
598 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(6)));
599
600 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
601 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo);
602 TestHelper::TearDownFrame(thread, prev);
603
604 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
605 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
606 ecmaRuntimeCallInfo1->SetThis(jsDate.GetTaggedValue());
607 // 18 : test case
608 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(18)));
609 // 10 : test case
610 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
611 // 2, 6 : test case
612 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<double>(6)));
613 // 3, 111 : test case
614 ecmaRuntimeCallInfo1->SetCallArg(3, JSTaggedValue(static_cast<double>(111)));
615
616 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
617 BuiltinsDate::SetHours(ecmaRuntimeCallInfo1);
618 TestHelper::TearDownFrame(thread, prev);
619 }
620
SetAll1(JSThread * thread,const JSHandle<JSDate> & jsDate)621 void SetAll1(JSThread *thread, const JSHandle<JSDate> &jsDate)
622 {
623 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
624 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
625 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
626 // 1900 : test case
627 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(1900)));
628 // 11 : test case
629 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(11)));
630 // 2, 31 : test case
631 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(31)));
632
633 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
634 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo);
635 TestHelper::TearDownFrame(thread, prev);
636
637 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
638 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
639 ecmaRuntimeCallInfo1->SetThis(jsDate.GetTaggedValue());
640 // 23 : test case
641 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(23)));
642 // 54 : test case
643 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<double>(54)));
644 // 2, 16 : test case
645 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<double>(16)));
646 // 3, 888 : test case
647 ecmaRuntimeCallInfo1->SetCallArg(3, JSTaggedValue(static_cast<double>(888)));
648
649 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
650 BuiltinsDate::SetHours(ecmaRuntimeCallInfo1);
651 TestHelper::TearDownFrame(thread, prev);
652 }
653
SetAll2(JSThread * thread,const JSHandle<JSDate> & jsDate)654 void SetAll2(JSThread *thread, const JSHandle<JSDate> &jsDate)
655 {
656 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
657 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
658 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
659 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<double>(1901))); // 1901 : test case
660 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<double>(0)));
661 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<double>(1))); // 2 : test case
662
663 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
664 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo);
665 TestHelper::TearDownFrame(thread, prev);
666
667 // 12 : test case
668 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
669 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
670 ecmaRuntimeCallInfo1->SetThis(jsDate.GetTaggedValue());
671 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(0)));
672 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<double>(3))); // 3 : test case
673 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<double>(21))); // 2, 21 : test case
674 ecmaRuntimeCallInfo1->SetCallArg(3, JSTaggedValue(static_cast<double>(129))); // 3, 129 : test case
675
676 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
677 BuiltinsDate::SetHours(ecmaRuntimeCallInfo1);
678 TestHelper::TearDownFrame(thread, prev);
679 }
680
HWTEST_F_L0(BuiltinsDateTest,parse)681 HWTEST_F_L0(BuiltinsDateTest, parse)
682 {
683 JSHandle<EcmaString> str =
684 thread->GetEcmaVM()->GetFactory()->NewFromASCII("2020-11-19T12:18:18.132Z");
685 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
686 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
687 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
688 ecmaRuntimeCallInfo->SetCallArg(0, str.GetTaggedValue());
689
690 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
691 JSTaggedValue result1 = BuiltinsDate::Parse(ecmaRuntimeCallInfo);
692 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1605788298132)).GetRawData());
693
694 JSHandle<EcmaString> str1 = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2020-11-19Z");
695 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
696 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
697 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
698 ecmaRuntimeCallInfo1->SetCallArg(0, str1.GetTaggedValue());
699
700 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
701 result1 = BuiltinsDate::Parse(ecmaRuntimeCallInfo1);
702 TestHelper::TearDownFrame(thread, prev);
703 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1605744000000)).GetRawData());
704
705 JSHandle<EcmaString> str2 =
706 thread->GetEcmaVM()->GetFactory()->NewFromASCII("2020-11T12:18:17.231+08:00");
707 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
708 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
709 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue::Undefined());
710 ecmaRuntimeCallInfo2->SetCallArg(0, str2.GetTaggedValue());
711
712 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
713 result1 = BuiltinsDate::Parse(ecmaRuntimeCallInfo2);
714 TestHelper::TearDownFrame(thread, prev);
715 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1604204297231)).GetRawData());
716
717 JSHandle<EcmaString> str3 =
718 thread->GetEcmaVM()->GetFactory()->NewFromASCII("Thu Nov 19 2020 20:18:18 GMT+0800");
719 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
720 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
721 ecmaRuntimeCallInfo3->SetThis(JSTaggedValue::Undefined());
722 ecmaRuntimeCallInfo3->SetCallArg(0, str3.GetTaggedValue());
723
724 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
725 result1 = BuiltinsDate::Parse(ecmaRuntimeCallInfo3);
726 TestHelper::TearDownFrame(thread, prev);
727 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1605788298000)).GetRawData());
728
729 JSHandle<EcmaString> str4 =
730 thread->GetEcmaVM()->GetFactory()->NewFromASCII("Thu 03 Jun 2093 04:18 GMT");
731 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
732 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
733 ecmaRuntimeCallInfo4->SetThis(JSTaggedValue::Undefined());
734 ecmaRuntimeCallInfo4->SetCallArg(0, str4.GetTaggedValue());
735
736 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
737 result1 = BuiltinsDate::Parse(ecmaRuntimeCallInfo4);
738 TestHelper::TearDownFrame(thread, prev);
739 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(3894841080000)).GetRawData());
740
741 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
742 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
743 ecmaRuntimeCallInfo5->SetThis(JSTaggedValue::Undefined());
744 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue::Null());
745
746 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
747 result1 = BuiltinsDate::Parse(ecmaRuntimeCallInfo5);
748 TestHelper::TearDownFrame(thread, prev);
749 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(base::NAN_VALUE)).GetRawData());
750 }
751
HWTEST_F_L0(BuiltinsDateTest,ToDateString)752 HWTEST_F_L0(BuiltinsDateTest, ToDateString)
753 {
754 JSHandle<EcmaString> expect_value =
755 thread->GetEcmaVM()->GetFactory()->NewFromASCII("Tue Nov 06 2018");
756 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
757 SetAllYearAndHours(thread, jsDate);
758
759 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
760 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
761 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
762
763 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
764 JSTaggedValue result = BuiltinsDate::ToDateString(ecmaRuntimeCallInfo);
765 TestHelper::TearDownFrame(thread, prev);
766
767 ASSERT_TRUE(result.IsString());
768 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
769 reinterpret_cast<EcmaString *>(result.GetRawData()), *expect_value));
770 }
771
HWTEST_F_L0(BuiltinsDateTest,ToISOString)772 HWTEST_F_L0(BuiltinsDateTest, ToISOString)
773 {
774 JSHandle<EcmaString> expect_value =
775 thread->GetEcmaVM()->GetFactory()->NewFromASCII("2020-11-19T12:18:18.132Z");
776 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
777 JSDate::Cast(jsDate.GetTaggedValue().GetTaggedObject())->SetTimeValue(thread, JSTaggedValue(1605788298132.0));
778 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
779 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
780 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
781
782 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
783 JSTaggedValue result1 = BuiltinsDate::ToISOString(ecmaRuntimeCallInfo);
784 TestHelper::TearDownFrame(thread, prev);
785 ASSERT_TRUE(result1.IsString());
786 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
787 reinterpret_cast<EcmaString *>(result1.GetRawData()), *expect_value));
788 }
789
HWTEST_F_L0(BuiltinsDateTest,ToISOStringMinus)790 HWTEST_F_L0(BuiltinsDateTest, ToISOStringMinus)
791 {
792 JSHandle<EcmaString> expect_value =
793 thread->GetEcmaVM()->GetFactory()->NewFromASCII("1831-12-02T21:47:18.382Z");
794 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
795 JSDate::Cast(jsDate.GetTaggedValue().GetTaggedObject())->SetTimeValue(thread, JSTaggedValue(-4357419161618.0));
796
797 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
798 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
799 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
800
801 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
802 JSTaggedValue result1 = BuiltinsDate::ToISOString(ecmaRuntimeCallInfo);
803 TestHelper::TearDownFrame(thread, prev);
804 ASSERT_TRUE(result1.IsString());
805 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
806 reinterpret_cast<EcmaString *>(result1.GetRawData()), *expect_value));
807 }
808
809 // test toJSON and toPrimitive
HWTEST_F_L0(BuiltinsDateTest,ToJSON)810 HWTEST_F_L0(BuiltinsDateTest, ToJSON)
811 {
812 JSHandle<EcmaString> expect_value =
813 thread->GetEcmaVM()->GetFactory()->NewFromASCII("2020-11-19T12:18:18.132Z");
814 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
815 // number double finite
816 jsDate->SetTimeValue(thread, JSTaggedValue(1605788298132.0));
817 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
818 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
819 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
820
821 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
822 JSTaggedValue result1 = BuiltinsDate::ToJSON(ecmaRuntimeCallInfo);
823 TestHelper::TearDownFrame(thread, prev);
824 ASSERT_TRUE(result1.IsString());
825 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
826 reinterpret_cast<EcmaString *>(result1.GetRawData()), *expect_value));
827
828 // number double infinite
829 jsDate->SetTimeValue(thread, JSTaggedValue(base::POSITIVE_INFINITY));
830 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
831 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
832 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
833
834 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
835 result1 = BuiltinsDate::ToJSON(ecmaRuntimeCallInfo);
836 TestHelper::TearDownFrame(thread, prev);
837 ASSERT_EQ(result1, JSTaggedValue::Null());
838 }
839
HWTEST_F_L0(BuiltinsDateTest,ToJSONMinus)840 HWTEST_F_L0(BuiltinsDateTest, ToJSONMinus)
841 {
842 JSHandle<EcmaString> expect_value =
843 thread->GetEcmaVM()->GetFactory()->NewFromASCII("1831-12-02T21:47:18.382Z");
844 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
845 jsDate->SetTimeValue(thread, JSTaggedValue(-4357419161618.0));
846 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
847 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
848 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
849
850 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
851 JSTaggedValue result1 = BuiltinsDate::ToJSON(ecmaRuntimeCallInfo);
852 ASSERT_TRUE(result1.IsString());
853 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
854 reinterpret_cast<EcmaString *>(result1.GetRawData()), *expect_value));
855 }
856
HWTEST_F_L0(BuiltinsDateTest,ToString)857 HWTEST_F_L0(BuiltinsDateTest, ToString)
858 {
859 int localMin = 0;
860 CString localTime;
861
862 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
863 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
864 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
865 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
866
867 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
868
869 SetAllYearAndHours(thread, jsDate);
870 localMin = GetLocalOffsetFromOS(static_cast<int64_t>((*jsDate)->GetTimeValue().GetDouble()), true);
871 if (localMin >= 0) {
872 localTime += PLUS;
873 } else if (localMin < 0) {
874 localTime += NEG;
875 localMin = -localMin;
876 }
877 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin / MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
878 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin % MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
879 JSTaggedValue result1 = BuiltinsDate::ToString(ecmaRuntimeCallInfo);
880 ASSERT_TRUE(result1.IsString());
881 TestHelper::TearDownFrame(thread, prev);
882 JSHandle<EcmaString> result1_val(thread, reinterpret_cast<EcmaString *>(result1.GetRawData()));
883 CString str = "Tue Nov 06 2018 18:10:06 GMT" + localTime;
884 JSHandle<EcmaString> str_handle = thread->GetEcmaVM()->GetFactory()->NewFromASCII(str);
885 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*result1_val, *str_handle));
886
887 JSHandle<JSDate> js_date1 = JSDateCreateTest(thread);
888 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
889 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
890 ecmaRuntimeCallInfo1->SetThis(js_date1.GetTaggedValue());
891 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
892
893 SetAll1(thread, js_date1);
894 localTime = "";
895 localMin = GetLocalOffsetFromOS(static_cast<int64_t>((*js_date1)->GetTimeValue().GetDouble()), true);
896 if (localMin >= 0) {
897 localTime += PLUS;
898 } else if (localMin < 0) {
899 localTime += NEG;
900 localMin = -localMin;
901 }
902 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin / MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
903 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin % MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
904 JSTaggedValue result2 = BuiltinsDate::ToString(ecmaRuntimeCallInfo1);
905 ASSERT_TRUE(result2.IsString());
906 TestHelper::TearDownFrame(thread, prev);
907 JSHandle<EcmaString> result2_val(thread, reinterpret_cast<EcmaString *>(result2.GetRawData()));
908 str = "Mon Dec 31 1900 23:54:16 GMT" + localTime;
909 str_handle = thread->GetEcmaVM()->GetFactory()->NewFromASCII(str);
910 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*result2_val, *str_handle));
911
912 JSHandle<JSDate> js_date2 = JSDateCreateTest(thread);
913 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
914 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
915 ecmaRuntimeCallInfo2->SetThis(js_date2.GetTaggedValue());
916 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
917
918 SetAll2(thread, js_date2);
919 localTime = "";
920 localMin = GetLocalOffsetFromOS(static_cast<int64_t>((*js_date2)->GetTimeValue().GetDouble()), true);
921 if (localMin >= 0) {
922 localTime += PLUS;
923 } else if (localMin < 0) {
924 localTime += NEG;
925 localMin = -localMin;
926 }
927 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin / MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
928 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin % MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
929 JSTaggedValue result3 = BuiltinsDate::ToString(ecmaRuntimeCallInfo2);
930 ASSERT_TRUE(result3.IsString());
931 TestHelper::TearDownFrame(thread, prev);
932 JSHandle<EcmaString> result3_val(thread, reinterpret_cast<EcmaString *>(result3.GetRawData()));
933 str = "Tue Jan 01 1901 00:03:21 GMT" + localTime;
934 str_handle = thread->GetEcmaVM()->GetFactory()->NewFromASCII(str);
935 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*result3_val, *str_handle));
936 }
937
HWTEST_F_L0(BuiltinsDateTest,ToTimeString)938 HWTEST_F_L0(BuiltinsDateTest, ToTimeString)
939 {
940 int localMin = 0;
941 CString localTime;
942
943 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
944 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
945 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
946 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
947
948 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
949
950 SetAllYearAndHours(thread, jsDate);
951 localMin = GetLocalOffsetFromOS(static_cast<int64_t>((*jsDate)->GetTimeValue().GetDouble()), true);
952 if (localMin >= 0) {
953 localTime += PLUS;
954 } else if (localMin < 0) {
955 localTime += NEG;
956 localMin = -localMin;
957 }
958 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin / MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
959 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin % MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
960 JSTaggedValue result1 = BuiltinsDate::ToTimeString(ecmaRuntimeCallInfo);
961 TestHelper::TearDownFrame(thread, prev);
962 ASSERT_TRUE(result1.IsString());
963 JSHandle<EcmaString> result1_val(thread, reinterpret_cast<EcmaString *>(result1.GetRawData()));
964 CString str = "18:10:06 GMT" + localTime;
965 JSHandle<EcmaString> str_handle = thread->GetEcmaVM()->GetFactory()->NewFromASCII(str);
966 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*result1_val, *str_handle));
967
968 JSHandle<JSDate> js_date1 = JSDateCreateTest(thread);
969 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
970 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
971 ecmaRuntimeCallInfo1->SetThis(js_date1.GetTaggedValue());
972 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
973 SetAll1(thread, js_date1);
974 localTime = "";
975 localMin = GetLocalOffsetFromOS(static_cast<int64_t>((*js_date1)->GetTimeValue().GetDouble()), true);
976 if (localMin >= 0) {
977 localTime += PLUS;
978 } else if (localMin < 0) {
979 localTime += NEG;
980 localMin = -localMin;
981 }
982 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin / MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
983 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin % MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
984 JSTaggedValue result2 = BuiltinsDate::ToTimeString(ecmaRuntimeCallInfo1);
985 TestHelper::TearDownFrame(thread, prev);
986 ASSERT_TRUE(result2.IsString());
987 JSHandle<EcmaString> result2_val(thread, reinterpret_cast<EcmaString *>(result2.GetRawData()));
988 str = "23:54:16 GMT" + localTime;
989 str_handle = thread->GetEcmaVM()->GetFactory()->NewFromASCII(str);
990 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*result2_val, *str_handle));
991 JSHandle<JSDate> js_date2 = JSDateCreateTest(thread);
992 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
993 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
994 ecmaRuntimeCallInfo2->SetThis(js_date2.GetTaggedValue());
995 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
996 SetAll2(thread, js_date2);
997 localTime = "";
998 localMin = GetLocalOffsetFromOS(static_cast<int64_t>((*js_date2)->GetTimeValue().GetDouble()), true);
999 if (localMin >= 0) {
1000 localTime += PLUS;
1001 } else if (localMin < 0) {
1002 localTime += NEG;
1003 localMin = -localMin;
1004 }
1005 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin / MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
1006 localTime = localTime + JSDate::StrToTargetLength(ToCString(localMin % MINUTE_PER_HOUR), STR_LENGTH_OTHERS);
1007 JSTaggedValue result3 = BuiltinsDate::ToTimeString(ecmaRuntimeCallInfo2);
1008 TestHelper::TearDownFrame(thread, prev);
1009 ASSERT_TRUE(result3.IsString());
1010 JSHandle<EcmaString> result3_val(thread, reinterpret_cast<EcmaString *>(result3.GetRawData()));
1011 str = "00:03:21 GMT" + localTime;
1012 str_handle = thread->GetEcmaVM()->GetFactory()->NewFromASCII(str);
1013 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*result3_val, *str_handle));
1014 }
1015
HWTEST_F_L0(BuiltinsDateTest,ToUTCString)1016 HWTEST_F_L0(BuiltinsDateTest, ToUTCString)
1017 {
1018 JSHandle<EcmaString> expect_value =
1019 thread->GetEcmaVM()->GetFactory()->NewFromASCII("Thu, 19 Nov 2020 12:18:18 GMT");
1020 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
1021 JSDate::Cast(jsDate.GetTaggedValue().GetTaggedObject())->SetTimeValue(thread, JSTaggedValue(1605788298132.0));
1022 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1023 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1024 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
1025
1026 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1027 JSTaggedValue result1 = BuiltinsDate::ToUTCString(ecmaRuntimeCallInfo);
1028 ASSERT_TRUE(result1.IsString());
1029 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
1030 reinterpret_cast<EcmaString *>(result1.GetRawData()), *expect_value));
1031 }
1032
HWTEST_F_L0(BuiltinsDateTest,ToUTCStringMinus)1033 HWTEST_F_L0(BuiltinsDateTest, ToUTCStringMinus)
1034 {
1035 JSHandle<EcmaString> expect_value =
1036 thread->GetEcmaVM()->GetFactory()->NewFromASCII("Fri, 02 Dec 1831 21:47:18 GMT");
1037 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
1038 JSDate::Cast(jsDate.GetTaggedValue().GetTaggedObject())->SetTimeValue(thread, JSTaggedValue(-4357419161618.0));
1039 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1040 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1041 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
1042
1043 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1044 JSTaggedValue result1 = BuiltinsDate::ToUTCString(ecmaRuntimeCallInfo);
1045 ASSERT_TRUE(result1.IsString());
1046 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(
1047 reinterpret_cast<EcmaString *>(result1.GetRawData()), *expect_value));
1048 }
1049
HWTEST_F_L0(BuiltinsDateTest,ValueOf)1050 HWTEST_F_L0(BuiltinsDateTest, ValueOf)
1051 {
1052 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
1053 JSDate::Cast(jsDate.GetTaggedValue().GetTaggedObject())->SetTimeValue(thread, JSTaggedValue(1605788298132.0));
1054 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1055 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1056 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
1057
1058 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1059 JSTaggedValue result1 = BuiltinsDate::ValueOf(ecmaRuntimeCallInfo);
1060 TestHelper::TearDownFrame(thread, prev);
1061 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(1605788298132)).GetRawData());
1062
1063 // case :msg is not Date
1064 auto info1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1065 info1->SetFunction(JSTaggedValue::Undefined());
1066 info1->SetThis(JSTaggedValue::Undefined());
1067
1068 prev = TestHelper::SetupFrame(thread, info1);
1069 result1 = BuiltinsDate::ValueOf(info1);
1070 TestHelper::TearDownFrame(thread, prev);
1071 EXPECT_TRUE(thread->HasPendingException());
1072 EXPECT_EQ(result1, JSTaggedValue::Exception());
1073 thread->ClearException();
1074 }
1075
HWTEST_F_L0(BuiltinsDateTest,ValueOfMinus)1076 HWTEST_F_L0(BuiltinsDateTest, ValueOfMinus)
1077 {
1078 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
1079 JSDate::Cast(jsDate.GetTaggedValue().GetTaggedObject())->SetTimeValue(thread, JSTaggedValue(-4357419161618.0));
1080 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1081 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1082 ecmaRuntimeCallInfo->SetThis(jsDate.GetTaggedValue());
1083
1084 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1085 JSTaggedValue result1 = BuiltinsDate::ValueOf(ecmaRuntimeCallInfo);
1086 ASSERT_EQ(result1.GetRawData(), JSTaggedValue(static_cast<double>(-4357419161618)).GetRawData());
1087 }
1088
HWTEST_F_L0(BuiltinsDateTest,DateConstructor)1089 HWTEST_F_L0(BuiltinsDateTest, DateConstructor)
1090 {
1091 // case1: test new target is undefined.
1092 JSHandle<JSDate> jsDate = JSDateCreateTest(thread);
1093 JSHandle<GlobalEnv> globalEnv = thread->GetEcmaVM()->GetGlobalEnv();
1094 JSHandle<JSFunction> date_func(globalEnv->GetDateFunction());
1095 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1096 ecmaRuntimeCallInfo1->SetFunction(date_func.GetTaggedValue());
1097 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1098
1099 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1100 JSTaggedValue result1 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo1);
1101 TestHelper::TearDownFrame(thread, prev);
1102 ASSERT_TRUE(result1.IsString());
1103
1104 // case2: length == 0
1105 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 4);
1106 ecmaRuntimeCallInfo2->SetFunction(date_func.GetTaggedValue());
1107 ecmaRuntimeCallInfo2->SetThis(jsDate.GetTaggedValue());
1108
1109 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1110 JSTaggedValue result2 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo2);
1111 TestHelper::TearDownFrame(thread, prev);
1112 ASSERT_TRUE(result2.IsObject());
1113
1114 // case3: length == 1
1115 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 6);
1116 ecmaRuntimeCallInfo3->SetFunction(date_func.GetTaggedValue());
1117 ecmaRuntimeCallInfo3->SetThis(jsDate.GetTaggedValue());
1118 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1119
1120 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1121 JSTaggedValue result3 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo3);
1122 TestHelper::TearDownFrame(thread, prev);
1123 ASSERT_TRUE(result3.IsObject());
1124
1125 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 6);
1126 ecmaRuntimeCallInfo4->SetFunction(date_func.GetTaggedValue());
1127 ecmaRuntimeCallInfo4->SetThis(jsDate.GetTaggedValue());
1128 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1129 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1130 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo4);
1131 TestHelper::TearDownFrame(thread, prev);
1132
1133 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 6);
1134 ecmaRuntimeCallInfo5->SetFunction(date_func.GetTaggedValue());
1135 ecmaRuntimeCallInfo5->SetThis(jsDate.GetTaggedValue());
1136 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1137 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1138 JSTaggedValue result4 = BuiltinsDate::GetFullYear(ecmaRuntimeCallInfo5);
1139 TestHelper::TearDownFrame(thread, prev);
1140 ASSERT_EQ(result4.GetRawData(), JSTaggedValue(static_cast<double>(2018)).GetRawData());
1141
1142 // case4: length > 1
1143 auto ecmaRuntimeCallInfo6 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1144 ecmaRuntimeCallInfo6->SetFunction(date_func.GetTaggedValue());
1145 ecmaRuntimeCallInfo6->SetThis(jsDate.GetTaggedValue());
1146 ecmaRuntimeCallInfo6->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1147 ecmaRuntimeCallInfo6->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1148
1149 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo6);
1150 JSTaggedValue result5 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo6);
1151 TestHelper::TearDownFrame(thread, prev);
1152 ASSERT_TRUE(result5.IsObject());
1153
1154 SetAllYearAndHours(thread, jsDate);
1155
1156 auto ecmaRuntimeCallInfo7 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1157 ecmaRuntimeCallInfo7->SetFunction(date_func.GetTaggedValue());
1158 ecmaRuntimeCallInfo7->SetThis(jsDate.GetTaggedValue());
1159 ecmaRuntimeCallInfo7->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1160 ecmaRuntimeCallInfo7->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1161 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo7);
1162 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo7);
1163 TestHelper::TearDownFrame(thread, prev);
1164
1165 auto ecmaRuntimeCallInfo8 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1166 ecmaRuntimeCallInfo8->SetFunction(date_func.GetTaggedValue());
1167 ecmaRuntimeCallInfo8->SetThis(jsDate.GetTaggedValue());
1168 ecmaRuntimeCallInfo8->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1169 ecmaRuntimeCallInfo8->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1170 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo8);
1171 JSTaggedValue result6 = BuiltinsDate::GetFullYear(ecmaRuntimeCallInfo8);
1172 TestHelper::TearDownFrame(thread, prev);
1173 ASSERT_EQ(result6.GetRawData(), JSTaggedValue(static_cast<double>(2018)).GetRawData());
1174
1175 auto ecmaRuntimeCallInfo9 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1176 ecmaRuntimeCallInfo9->SetFunction(date_func.GetTaggedValue());
1177 ecmaRuntimeCallInfo9->SetThis(jsDate.GetTaggedValue());
1178 ecmaRuntimeCallInfo9->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1179 ecmaRuntimeCallInfo9->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1180 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo9);
1181 JSTaggedValue result7 = BuiltinsDate::GetMonth(ecmaRuntimeCallInfo9);
1182 TestHelper::TearDownFrame(thread, prev);
1183 ASSERT_EQ(result7.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
1184
1185 // case5: length > 7
1186 auto ecmaRuntimeCallInfo10 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 20);
1187 ecmaRuntimeCallInfo10->SetFunction(date_func.GetTaggedValue());
1188 ecmaRuntimeCallInfo10->SetThis(jsDate.GetTaggedValue());
1189 ecmaRuntimeCallInfo10->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1190 ecmaRuntimeCallInfo10->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1191 ecmaRuntimeCallInfo10->SetCallArg(2, JSTaggedValue(static_cast<double>(10)));
1192 ecmaRuntimeCallInfo10->SetCallArg(3, JSTaggedValue(static_cast<double>(10)));
1193 ecmaRuntimeCallInfo10->SetCallArg(4, JSTaggedValue(static_cast<double>(10)));
1194 ecmaRuntimeCallInfo10->SetCallArg(5, JSTaggedValue(static_cast<double>(10)));
1195 ecmaRuntimeCallInfo10->SetCallArg(6, JSTaggedValue(static_cast<double>(10)));
1196 ecmaRuntimeCallInfo10->SetCallArg(7, JSTaggedValue(static_cast<double>(10)));
1197
1198 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo10);
1199 JSTaggedValue result8 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo10);
1200 TestHelper::TearDownFrame(thread, prev);
1201 ASSERT_TRUE(result8.IsObject());
1202
1203 // case6: length > 1, NAN number
1204 auto ecmaRuntimeCallInfo11 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1205 ecmaRuntimeCallInfo11->SetFunction(date_func.GetTaggedValue());
1206 ecmaRuntimeCallInfo11->SetThis(jsDate.GetTaggedValue());
1207 ecmaRuntimeCallInfo11->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1208 ecmaRuntimeCallInfo11->SetCallArg(1, JSTaggedValue(static_cast<double>(base::NAN_VALUE)));
1209
1210 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo11);
1211 JSTaggedValue result9 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo11);
1212 TestHelper::TearDownFrame(thread, prev);
1213 ASSERT_TRUE(result9.IsObject());
1214 JSHandle<JSTaggedValue> result10(thread, result9);
1215 JSHandle<JSDate> dateResult1 = JSHandle<JSDate>::Cast(result10);
1216 ASSERT_EQ(dateResult1->GetTimeValue(), JSTaggedValue(static_cast<double>(base::NAN_VALUE)));
1217
1218 // case7: length > 1, infinite number
1219 auto ecmaRuntimeCallInfo12 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1220 ecmaRuntimeCallInfo12->SetFunction(date_func.GetTaggedValue());
1221 ecmaRuntimeCallInfo12->SetThis(jsDate.GetTaggedValue());
1222 ecmaRuntimeCallInfo12->SetCallArg(0, JSTaggedValue(static_cast<double>(2018)));
1223 ecmaRuntimeCallInfo12->SetCallArg(1, JSTaggedValue(static_cast<double>(base::POSITIVE_INFINITY)));
1224
1225 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo12);
1226 JSTaggedValue result11 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo12);
1227 TestHelper::TearDownFrame(thread, prev);
1228 ASSERT_TRUE(result11.IsObject());
1229 JSHandle<JSTaggedValue> result12(thread, result11);
1230 JSHandle<JSDate> dateResult2 = JSHandle<JSDate>::Cast(result12);
1231 ASSERT_EQ(dateResult2->GetTimeValue(), JSTaggedValue(static_cast<double>(base::NAN_VALUE)));
1232
1233 // case8: length > 1
1234 auto ecmaRuntimeCallInfo13 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1235 ecmaRuntimeCallInfo13->SetFunction(date_func.GetTaggedValue());
1236 ecmaRuntimeCallInfo13->SetThis(jsDate.GetTaggedValue());
1237 ecmaRuntimeCallInfo13->SetCallArg(0, JSTaggedValue(static_cast<double>(10)));
1238 ecmaRuntimeCallInfo13->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1239
1240 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo13);
1241 JSTaggedValue result13 = BuiltinsDate::DateConstructor(ecmaRuntimeCallInfo13);
1242 TestHelper::TearDownFrame(thread, prev);
1243 ASSERT_TRUE(result13.IsObject());
1244
1245 SetAllYearAndHours(thread, jsDate);
1246
1247 auto ecmaRuntimeCallInfo14 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1248 ecmaRuntimeCallInfo14->SetFunction(date_func.GetTaggedValue());
1249 ecmaRuntimeCallInfo14->SetThis(jsDate.GetTaggedValue());
1250 ecmaRuntimeCallInfo14->SetCallArg(0, JSTaggedValue(static_cast<double>(10)));
1251 ecmaRuntimeCallInfo14->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1252 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo14);
1253 BuiltinsDate::SetFullYear(ecmaRuntimeCallInfo14);
1254 TestHelper::TearDownFrame(thread, prev);
1255
1256 auto ecmaRuntimeCallInfo15 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1257 ecmaRuntimeCallInfo15->SetFunction(date_func.GetTaggedValue());
1258 ecmaRuntimeCallInfo15->SetThis(jsDate.GetTaggedValue());
1259 ecmaRuntimeCallInfo15->SetCallArg(0, JSTaggedValue(static_cast<double>(10)));
1260 ecmaRuntimeCallInfo15->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1261 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo15);
1262 JSTaggedValue result14 = BuiltinsDate::GetFullYear(ecmaRuntimeCallInfo15);
1263 TestHelper::TearDownFrame(thread, prev);
1264 ASSERT_EQ(result14.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
1265
1266 auto ecmaRuntimeCallInfo16 = TestHelper::CreateEcmaRuntimeCallInfo(thread, jsDate.GetTaggedValue(), 8);
1267 ecmaRuntimeCallInfo16->SetFunction(date_func.GetTaggedValue());
1268 ecmaRuntimeCallInfo16->SetThis(jsDate.GetTaggedValue());
1269 ecmaRuntimeCallInfo16->SetCallArg(0, JSTaggedValue(static_cast<double>(10)));
1270 ecmaRuntimeCallInfo16->SetCallArg(1, JSTaggedValue(static_cast<double>(10)));
1271 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo16);
1272 JSTaggedValue result15 = BuiltinsDate::GetMonth(ecmaRuntimeCallInfo16);
1273 TestHelper::TearDownFrame(thread, prev);
1274 ASSERT_EQ(result15.GetRawData(), JSTaggedValue(static_cast<double>(10)).GetRawData());
1275 }
1276 } // namespace panda::test
1277