1 /*
2 * Copyright (c) 2023 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 "native_engine/native_value.h"
17 #include "napi/native_api.h"
18 #include "napi/native_node_api.h"
19 #include "test.h"
20 #include "test_timer.h"
21 #include "../timer.h"
22 #include "utils/log.h"
23
24 using namespace Commonlibrary::Concurrent::Common;
25 using namespace OHOS::JsSysModule;
26
27 #define ASSERT_CHECK_CALL(call) \
28 { \
29 ASSERT_EQ(call, napi_ok); \
30 }
31
32 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
33 { \
34 napi_valuetype valueType = napi_undefined; \
35 ASSERT_TRUE((value) != nullptr); \
36 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
37 ASSERT_EQ(valueType, type); \
38 }
39
TimerCallback(napi_env env,napi_callback_info info)40 napi_value TimerCallback(napi_env env, napi_callback_info info)
41 {
42 if (info == nullptr) {
43 HILOG_ERROR("TimerCallback, Invalid input info.");
44 }
45 return nullptr;
46 }
47
48 /* @tc.name: Init
49 * @tc.desc: Test.
50 * @tc.type: FUNC
51 */
52 HWTEST_F(NativeEngineTest, TimerTest001, testing::ext::TestSize.Level0)
53 {
54 napi_env env = (napi_env)engine_;
55 bool res0 = Timer::RegisterTime(env);
56 ASSERT_TRUE(res0);
57 bool res1 = Timer::RegisterTime(nullptr);
58 ASSERT_TRUE(!res1);
59 }
60
61 /* @tc.name: settimeout
62 * @tc.desc: Test.
63 * @tc.type: FUNC
64 */
65 HWTEST_F(NativeEngineTest, TimerTest002, testing::ext::TestSize.Level0)
66 {
67 napi_env env = (napi_env)engine_;
68 size_t argc = 0;
69 napi_value argv0[] = {nullptr}; // no args has exception
70 napi_value cb = nullptr;
71 napi_create_function(env, "setInterval", NAPI_AUTO_LENGTH, TimerTest::SetInterval, nullptr, &cb);
72 napi_value res = nullptr;
73 napi_call_function(env, nullptr, cb, argc, argv0, &res);
74 ASSERT_TRUE(res == nullptr);
75 bool res0 = 0;
76 napi_is_exception_pending(env, &res0);
77 ASSERT_TRUE(res0);
78 napi_value exception = nullptr;
79 napi_get_and_clear_last_exception(env, &exception);
80 }
81
82 /* @tc.name: settimeout
83 * @tc.desc: Test.
84 * @tc.type: FUNC
85 */
86 HWTEST_F(NativeEngineTest, TimerTest003, testing::ext::TestSize.Level0)
87 {
88 napi_env env = (napi_env)engine_;
89 size_t argc = 2;
90 napi_value nativeMessage0 = nullptr;
91 napi_create_uint32(env, 5, &nativeMessage0); // Random number
92 napi_value nativeMessage1 = nullptr;
93 napi_create_uint32(env, 50, &nativeMessage1); // Random number
94 napi_value argv[] = {nativeMessage0, nativeMessage1};
95 napi_value cb = nullptr;
96 napi_create_function(env, "setTimeout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &cb); // uncallable
97 napi_value tId = nullptr;
98 napi_call_function(env, nullptr, cb, argc, argv, &tId);
99 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_undefined);
100 }
101
102 /* @tc.name: settimeout/ClearTimer
103 * @tc.desc: Test.
104 * @tc.type: FUNC
105 */
106 HWTEST_F(NativeEngineTest, TimerTest004, testing::ext::TestSize.Level0)
107 {
108 napi_env env = (napi_env)engine_;
109 size_t argc = 2;
110 napi_value nativeMessage0 = nullptr;
111 napi_create_uint32(env, 50, &nativeMessage0); // Random number
112 napi_value nativeMessage1 = nullptr;
113 napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
114 napi_value argv[] = {nativeMessage1, nativeMessage0};
115 napi_value setTimeoutCB = nullptr;
116 napi_create_function(env, "setTimeout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &setTimeoutCB);
117 napi_value tId = nullptr;
118 napi_call_function(env, nullptr, setTimeoutCB, argc, argv, &tId);
119 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
120 napi_value argv1[] = {tId};
121 napi_value clearTimerCB = nullptr;
122 napi_create_function(env, "clearTimer", NAPI_AUTO_LENGTH, TimerTest::ClearTimer, nullptr, &clearTimerCB);
123 napi_value res = nullptr;
124 napi_call_function(env, nullptr, clearTimerCB, 1, argv1, &res);
125 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
126 }
127
128 /* @tc.name: settimeout
129 * @tc.desc: Test.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(NativeEngineTest, TimerTest005, testing::ext::TestSize.Level0)
133 {
134 napi_env env = (napi_env)engine_;
135 size_t argc = 2;
136 int32_t number = -50.0; // Random number
137 napi_value nativeMessage0 = nullptr;
138 napi_create_int32(env, number, &nativeMessage0);
139 napi_value nativeMessage1 = nullptr;
140 napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
141 napi_value argv[] = {nativeMessage1, nativeMessage0};
142 napi_value cb = nullptr;
143 napi_create_function(env, "setTimerout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &cb);
144 napi_value tId = nullptr;
145 napi_call_function(env, nullptr, cb, argc, argv, &tId);
146 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
147 }
148
149 /* @tc.name: settimeout
150 * @tc.desc: Test.
151 * @tc.type: FUNC
152 */
153 HWTEST_F(NativeEngineTest, TimerTest006, testing::ext::TestSize.Level0)
154 {
155 napi_env env = (napi_env)engine_;
156 size_t argc = 2;
157 napi_value nativeMessage0 = nullptr;
158 napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage0);
159 std::string message = "50";
160 napi_value nativeMessage1 = nullptr;
161 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage1); // timeout is string
162 napi_value argv[] = {nativeMessage0, nativeMessage1};
163 napi_value cb = nullptr;
164 napi_create_function(env, "setTimerout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &cb);
165 napi_value tId = nullptr;
166 napi_call_function(env, nullptr, cb, argc, argv, &tId);
167 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
168 }
169
170 /* @tc.name: ClearTimer
171 * @tc.desc: Test.
172 * @tc.type: FUNC
173 */
174 HWTEST_F(NativeEngineTest, TimerTest007, testing::ext::TestSize.Level0)
175 {
176 napi_env env = (napi_env)engine_;
177 size_t argc = 0;
178 napi_value argv[] = {nullptr}; // no args
179 napi_value cb = nullptr;
180 napi_create_function(env, "clearTimer", NAPI_AUTO_LENGTH, TimerTest::ClearTimer, nullptr, &cb);
181 napi_value res = nullptr;
182 napi_call_function(env, nullptr, cb, argc, argv, &res);
183 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
184 }
185
186 /* @tc.name: ClearTimer
187 * @tc.desc: Test.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(NativeEngineTest, TimerTest008, testing::ext::TestSize.Level0)
191 {
192 napi_env env = (napi_env)engine_;
193 size_t argc = 1;
194 napi_value nativeMessage = nullptr;
195 std::string message = "50"; // Random number
196 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage);
197 napi_value argv[] = {nativeMessage};
198 napi_value cb = nullptr;
199 napi_create_function(env, "clearTimer", NAPI_AUTO_LENGTH, TimerTest::ClearTimer, nullptr, &cb);
200 napi_value res = nullptr;
201 napi_call_function(env, nullptr, cb, argc, argv, &res);
202 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
203 }
204
205 /* @tc.name: ClearTimer
206 * @tc.desc: Test.
207 * @tc.type: FUNC
208 */
209 HWTEST_F(NativeEngineTest, TimerTest009, testing::ext::TestSize.Level0)
210 {
211 napi_env env = (napi_env)engine_;
212 size_t argc = 1;
213 napi_value cb = nullptr;
214 napi_value inputId = nullptr;
215 napi_create_uint32(env, 50, &inputId); // Random number
216 napi_value argv[] = { inputId }; // timerId is inexistent
217 napi_create_function(env, "clearTimer", NAPI_AUTO_LENGTH, TimerTest::ClearTimer, nullptr, &cb);
218 napi_value res = nullptr;
219 napi_call_function(env, nullptr, cb, argc, argv, &res);
220 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
221 }
222
223 /* @tc.name: setinteval
224 * @tc.desc: Test.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(NativeEngineTest, TimerTest010, testing::ext::TestSize.Level0)
228 {
229 napi_env env = (napi_env)engine_;
230 size_t argc = 2;
231 napi_value nativeMessage0 = nullptr;
232 napi_create_uint32(env, 5, &nativeMessage0); // Random number
233 napi_value nativeMessage1 = nullptr;
234 napi_create_uint32(env, 50, &nativeMessage1); // Random number
235 napi_value argv1[] = {nativeMessage0, nativeMessage1};
236 napi_value cb1 = nullptr;
237 napi_create_function(env, "setInterval", NAPI_AUTO_LENGTH, TimerTest::SetInterval, nullptr, &cb1); // uncallable
238 napi_value tId1 = nullptr;
239 napi_call_function(env, nullptr, cb1, argc, argv1, &tId1);
240 ASSERT_CHECK_VALUE_TYPE(env, tId1, napi_undefined);
241 napi_value nativeMessage2 = nullptr;
242 napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage2);
243 napi_value argv2[] = {nativeMessage2, nativeMessage1};
244 napi_value tId2 = nullptr;
245 napi_value cb2 = nullptr;
246 napi_create_function(env, "setInterval", NAPI_AUTO_LENGTH, TimerTest::SetInterval, nullptr, &cb2);
247 napi_call_function(env, nullptr, cb2, argc, argv2, &tId2);
248 ASSERT_CHECK_VALUE_TYPE(env, tId2, napi_number);
249 int32_t number = -50.0; // Random number
250 napi_value nativeMessage3 = nullptr;
251 napi_create_int32(env, number, &nativeMessage3);
252 napi_value argv3[] = {nativeMessage2, nativeMessage3};
253 napi_value tId3 = nullptr;
254 napi_value cb3 = nullptr;
255 napi_create_function(env, "setTimeout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &cb3);
256 napi_call_function(env, nullptr, cb3, argc, argv3, &tId3);
257 ASSERT_CHECK_VALUE_TYPE(env, tId3, napi_number);
258 std::string message = "50"; // Random number
259 napi_value nativeMessage4 = nullptr;
260 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage4);
261 napi_value argv4[] = {nativeMessage2, nativeMessage4};
262 napi_value tId4 = nullptr;
263 napi_value cb4 = nullptr;
264 napi_create_function(env, "setInterval", NAPI_AUTO_LENGTH, TimerTest::SetInterval, nullptr, &cb4);
265 napi_call_function(env, nullptr, cb4, argc, argv4, &tId4);
266 ASSERT_CHECK_VALUE_TYPE(env, tId4, napi_number);
267
268 bool res0 = Timer::HasTimer(env);
269 ASSERT_TRUE(res0);
270 Timer::ClearEnvironmentTimer(env);
271 bool res1 = Timer::HasTimer(env);
272 ASSERT_TRUE(!res1);
273 }
274
275 /* @tc.name: settimeout
276 * @tc.desc: Test.
277 * @tc.type: FUNC
278 */
279 HWTEST_F(NativeEngineTest, TimerTest011, testing::ext::TestSize.Level0)
280 {
281 napi_env env = (napi_env)engine_;
282 size_t argc = 1; // argc = 1, timeout = 0
283
284 napi_value tId = nullptr;
285 napi_value cb = nullptr;
286 napi_value nativeMessage1 = nullptr;
287 napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
288 napi_value argv[] = {nativeMessage1};
289 napi_create_function(env, "setTimeout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &cb);
290 napi_call_function(env, nullptr, cb, argc, argv, &tId);
291 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
292 }
293
294 /* @tc.name: settimeout
295 * @tc.desc: Test: callbackArgc > 0
296 * @tc.type: FUNC
297 */
298 HWTEST_F(NativeEngineTest, TimerTest012, testing::ext::TestSize.Level0)
299 {
300 napi_env env = (napi_env)engine_;
301 size_t argc = 3;
302 napi_value tId = nullptr;
303 napi_value cb = nullptr;
304 napi_value nativeMessage0 = nullptr;
305 napi_create_uint32(env, 50, &nativeMessage0); // Random number
306 napi_value nativeMessage2 = nullptr;
307 napi_create_uint32(env, 50, &nativeMessage2); // Random number
308 napi_value nativeMessage1 = nullptr;
309 napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
310 napi_value argv[] = {nativeMessage1, nativeMessage0, nativeMessage2};
311 napi_create_function(env, "setTimeout", NAPI_AUTO_LENGTH, TimerTest::SetTimeout, nullptr, &cb);
312 napi_call_function(env, nullptr, cb, argc, argv, &tId);
313 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
314 }
315