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 "tools/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 
GetGlobalProperty(napi_env env,const char * name)48 napi_value GetGlobalProperty(napi_env env, const char *name)
49 {
50     napi_value value = nullptr;
51     napi_value global;
52     napi_get_global(env, &global);
53     napi_get_named_property(env, global, name, &value);
54     return value;
55 }
56 
57 /* @tc.name: Init
58  * @tc.desc: Test.
59  * @tc.type: FUNC
60  */
61 HWTEST_F(NativeEngineTest, TimerTest001, testing::ext::TestSize.Level0)
62 {
63     napi_env env = (napi_env)engine_;
64     bool res0 = Timer::RegisterTime(env);
65     ASSERT_TRUE(res0);
66     bool res1 = Timer::RegisterTime(nullptr);
67     ASSERT_TRUE(!res1);
68 }
69 
70 /* @tc.name: settimeout
71  * @tc.desc: Test.
72  * @tc.type: FUNC
73  */
74 HWTEST_F(NativeEngineTest, TimerTest002, testing::ext::TestSize.Level0)
75 {
76     napi_env env = (napi_env)engine_;
77     size_t argc = 0;
78     napi_value argv0[] = {nullptr}; // no args has exception
79     napi_value cb = GetGlobalProperty(env, "setInterval");
80     napi_value res = nullptr;
81     napi_call_function(env, nullptr, cb, argc, argv0, &res);
82     ASSERT_TRUE(res == nullptr);
83     bool res0 = 0;
84     napi_is_exception_pending(env, &res0);
85     ASSERT_TRUE(res0);
86     napi_value exception = nullptr;
87     napi_get_and_clear_last_exception(env, &exception);
88 }
89 
90 /* @tc.name: settimeout
91  * @tc.desc: Test.
92  * @tc.type: FUNC
93  */
94 HWTEST_F(NativeEngineTest, TimerTest003, testing::ext::TestSize.Level0)
95 {
96     napi_env env = (napi_env)engine_;
97     size_t argc = 2;
98     napi_value nativeMessage0 = nullptr;
99     napi_create_uint32(env, 5, &nativeMessage0); // Random number
100     napi_value nativeMessage1 = nullptr;
101     napi_create_uint32(env, 50, &nativeMessage1); // Random number
102     napi_value argv[] = {nativeMessage0, nativeMessage1};
103     napi_value cb = GetGlobalProperty(env, "setTimeout");
104     napi_value tId = nullptr;
105     napi_call_function(env, nullptr, cb, argc, argv, &tId);
106     ASSERT_CHECK_VALUE_TYPE(env, tId, napi_undefined);
107 }
108 
109 /* @tc.name: settimeout/ClearTimer
110  * @tc.desc: Test.
111  * @tc.type: FUNC
112  */
113 HWTEST_F(NativeEngineTest, TimerTest004, testing::ext::TestSize.Level0)
114 {
115     napi_env env = (napi_env)engine_;
116     size_t argc = 2;
117     napi_value nativeMessage0 = nullptr;
118     napi_create_uint32(env, 50, &nativeMessage0); // Random number
119     napi_value nativeMessage1 = nullptr;
120     napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
121     napi_value argv[] = {nativeMessage1, nativeMessage0};
122     napi_value setTimeoutCB = GetGlobalProperty(env, "setTimeout");
123     napi_value tId = nullptr;
124     napi_call_function(env, nullptr, setTimeoutCB, argc, argv, &tId);
125     ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
126     napi_value argv1[] = {tId};
127     napi_value clearTimerCB = GetGlobalProperty(env, "clearTimeout");
128     napi_value res = nullptr;
129     napi_call_function(env, nullptr, clearTimerCB, 1, argv1, &res);
130     ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
131 }
132 
133 /* @tc.name: settimeout
134  * @tc.desc: Test.
135  * @tc.type: FUNC
136  */
137 HWTEST_F(NativeEngineTest, TimerTest005, testing::ext::TestSize.Level0)
138 {
139     napi_env env = (napi_env)engine_;
140     size_t argc = 2;
141     int32_t number = -50.0; // Random number
142     napi_value nativeMessage0 = nullptr;
143     napi_create_int32(env, number, &nativeMessage0);
144     napi_value nativeMessage1 = nullptr;
145     napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
146     napi_value argv[] = {nativeMessage1, nativeMessage0};
147     napi_value cb = GetGlobalProperty(env, "setTimeout");
148     napi_value tId = nullptr;
149     napi_call_function(env, nullptr, cb, argc, argv, &tId);
150     ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
151 }
152 
153 /* @tc.name: settimeout
154  * @tc.desc: Test.
155  * @tc.type: FUNC
156  */
157 HWTEST_F(NativeEngineTest, TimerTest006, testing::ext::TestSize.Level0)
158 {
159     napi_env env = (napi_env)engine_;
160     size_t argc = 2;
161     napi_value nativeMessage0 = nullptr;
162     napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage0);
163     std::string message = "50";
164     napi_value nativeMessage1 = nullptr;
165     napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage1); // timeout is string
166     napi_value argv[] = {nativeMessage0, nativeMessage1};
167     napi_value cb = GetGlobalProperty(env, "setTimeout");
168     napi_value tId = nullptr;
169     napi_call_function(env, nullptr, cb, argc, argv, &tId);
170     ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
171 }
172 
173 /* @tc.name: ClearTimer
174  * @tc.desc: Test.
175  * @tc.type: FUNC
176  */
177 HWTEST_F(NativeEngineTest, TimerTest007, testing::ext::TestSize.Level0)
178 {
179     napi_env env = (napi_env)engine_;
180     size_t argc = 0;
181     napi_value argv[] = {nullptr}; // no args
182     napi_value cb = GetGlobalProperty(env, "clearTimeout");
183     napi_value res = nullptr;
184     napi_call_function(env, nullptr, cb, argc, argv, &res);
185     ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
186 }
187 
188 /* @tc.name: ClearTimer
189  * @tc.desc: Test.
190  * @tc.type: FUNC
191  */
192 HWTEST_F(NativeEngineTest, TimerTest008, testing::ext::TestSize.Level0)
193 {
194     napi_env env = (napi_env)engine_;
195     size_t argc = 1;
196     napi_value nativeMessage = nullptr;
197     std::string message = "50"; // Random number
198     napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage);
199     napi_value argv[] = {nativeMessage};
200     napi_value cb = GetGlobalProperty(env, "clearTimeout");
201     napi_value res = nullptr;
202     napi_call_function(env, nullptr, cb, argc, argv, &res);
203     ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
204 }
205 
206 /* @tc.name: ClearTimer
207  * @tc.desc: Test.
208  * @tc.type: FUNC
209  */
210 HWTEST_F(NativeEngineTest, TimerTest009, testing::ext::TestSize.Level0)
211 {
212     napi_env env = (napi_env)engine_;
213     size_t argc = 1;
214     napi_value cb = GetGlobalProperty(env, "clearTimeout");
215     napi_value inputId = nullptr;
216     napi_create_uint32(env, 50, &inputId); // Random number
217     napi_value argv[] = { inputId }; // timerId is inexistent
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 = GetGlobalProperty(env, "setInterval");
237     napi_value tId1 = nullptr;
238     napi_call_function(env, nullptr, cb1, argc, argv1, &tId1);
239     ASSERT_CHECK_VALUE_TYPE(env, tId1, napi_undefined);
240     napi_value nativeMessage2 = nullptr;
241     napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage2);
242     napi_value argv2[] = {nativeMessage2, nativeMessage1};
243     napi_value tId2 = nullptr;
244     napi_value cb2 = GetGlobalProperty(env, "setInterval");
245     napi_call_function(env, nullptr, cb2, argc, argv2, &tId2);
246     ASSERT_CHECK_VALUE_TYPE(env, tId2, napi_number);
247     int32_t number = -50.0; // Random number
248     napi_value nativeMessage3 = nullptr;
249     napi_create_int32(env, number, &nativeMessage3);
250     napi_value argv3[] = {nativeMessage2, nativeMessage3};
251     napi_value tId3 = nullptr;
252     napi_value cb3 = GetGlobalProperty(env, "setTimeout");
253     napi_call_function(env, nullptr, cb3, argc, argv3, &tId3);
254     ASSERT_CHECK_VALUE_TYPE(env, tId3, napi_number);
255     std::string message = "50"; // Random number
256     napi_value nativeMessage4 = nullptr;
257     napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage4);
258     napi_value argv4[] = {nativeMessage2, nativeMessage4};
259     napi_value tId4 = nullptr;
260     napi_value cb4 = GetGlobalProperty(env, "setInterval");
261     napi_call_function(env, nullptr, cb4, argc, argv4, &tId4);
262     ASSERT_CHECK_VALUE_TYPE(env, tId4, napi_number);
263 
264     bool res0 = Timer::HasTimer(env);
265     ASSERT_TRUE(res0);
266     Timer::ClearEnvironmentTimer(env);
267     bool res1 = Timer::HasTimer(env);
268     ASSERT_TRUE(!res1);
269 }
270 
271 /* @tc.name: settimeout
272  * @tc.desc: Test.
273  * @tc.type: FUNC
274  */
275 HWTEST_F(NativeEngineTest, TimerTest011, testing::ext::TestSize.Level0)
276 {
277     napi_env env = (napi_env)engine_;
278     size_t argc = 1;  // argc = 1, timeout = 0
279 
280     napi_value tId = nullptr;
281     napi_value cb = GetGlobalProperty(env, "setTimeout");
282     napi_value nativeMessage1 = nullptr;
283     napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
284     napi_value argv[] = {nativeMessage1};
285     napi_call_function(env, nullptr, cb, argc, argv, &tId);
286     ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
287 }
288 
289 /* @tc.name: settimeout
290  * @tc.desc: Test: callbackArgc > 0
291  * @tc.type: FUNC
292  */
293 HWTEST_F(NativeEngineTest, TimerTest012, testing::ext::TestSize.Level0)
294 {
295     napi_env env = (napi_env)engine_;
296     size_t argc = 3;
297     napi_value tId = nullptr;
298     napi_value cb = GetGlobalProperty(env, "setTimeout");
299     napi_value nativeMessage0 = nullptr;
300     napi_create_uint32(env, 50, &nativeMessage0); // Random number
301     napi_value nativeMessage2 = nullptr;
302     napi_create_uint32(env, 50, &nativeMessage2); // Random number
303     napi_value nativeMessage1 = nullptr;
304     napi_create_function(env, "callback", NAPI_AUTO_LENGTH, TimerCallback, nullptr, &nativeMessage1);
305     napi_value argv[] = {nativeMessage1, nativeMessage0, nativeMessage2};
306     napi_call_function(env, nullptr, cb, argc, argv, &tId);
307     ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
308 }
309