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