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(NativeEngine * engine,NativeCallbackInfo * info)40 NativeValue *TimerCallback(NativeEngine *engine, NativeCallbackInfo *info)
41 {
42 if (info == nullptr || info->functionInfo == nullptr || info->functionInfo->data == nullptr) {
43 HILOG_ERROR("TimerCallback, Invalid input info.");
44 return nullptr;
45 }
46 return nullptr;
47 }
48
napi_create_cbinfo(napi_env env,size_t * argc,NativeValue ** argv)49 napi_callback_info napi_create_cbinfo(napi_env env,
50 size_t* argc,
51 NativeValue** argv)
52 {
53 NativeCallbackInfo* info = new NativeCallbackInfo;
54
55 if (argv != nullptr && argc != nullptr) {
56 info->argc = *argc;
57 info->argv = argv;
58 return reinterpret_cast<napi_callback_info>(info);
59 }
60 return nullptr;
61 }
62 /* @tc.name: Init
63 * @tc.desc: Test.
64 * @tc.type: FUNC
65 */
66 HWTEST_F(NativeEngineTest, TimerTest001, testing::ext::TestSize.Level0)
67 {
68 napi_env env = (napi_env)engine_;
69 bool res0 = Timer::RegisterTime(env);
70 ASSERT_TRUE(res0);
71 bool res1 = Timer::RegisterTime(nullptr);
72 ASSERT_TRUE(!res1);
73 }
74
75 /* @tc.name: settimeout
76 * @tc.desc: Test.
77 * @tc.type: FUNC
78 */
79 HWTEST_F(NativeEngineTest, TimerTest002, testing::ext::TestSize.Level0)
80 {
81 napi_env env = (napi_env)engine_;
82 size_t argc = 0;
83 NativeValue* argv0[] = {nullptr};
84 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0); // no args has exception
85 napi_value tId0 = TimerTest::SetInterval(env, cbinfo0);
86 ASSERT_TRUE(tId0 == nullptr);
87 bool res0 = 0;
88 napi_is_exception_pending(env, &res0);
89 ASSERT_TRUE(res0);
90 engine_->GetAndClearLastException();
91 }
92
93 /* @tc.name: settimeout
94 * @tc.desc: Test.
95 * @tc.type: FUNC
96 */
97 HWTEST_F(NativeEngineTest, TimerTest003, testing::ext::TestSize.Level0)
98 {
99 napi_env env = (napi_env)engine_;
100 size_t argc = 2;
101 NativeValue* nativeMessage0 = engine_->CreateNumber(5); // Random number
102 NativeValue* nativeMessage1 = engine_->CreateNumber(50); // Random number
103 NativeValue* argv[] = {nativeMessage0, nativeMessage1};
104 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv); // uncallable
105 napi_value tId = TimerTest::SetTimeout(env, cbinfo);
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 NativeValue* nativeMessage0 = engine_->CreateNumber(50); // Random number
118 NativeValue* nativeMessage1 = engine_->CreateFunction("callback", strlen("callback"),
119 TimerCallback, nullptr);
120 NativeValue* argv[] = {nativeMessage1, nativeMessage0};
121 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
122 napi_value tId = TimerTest::SetTimeout(env, cbinfo);
123 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
124
125 NativeValue* inputId = reinterpret_cast<NativeValue*>(tId);
126 NativeValue* argv1[] = {inputId};
127 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc, argv1);
128 napi_value res = TimerTest::ClearTimer(env, cbinfo1);
129 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
130 }
131
132 /* @tc.name: settimeout
133 * @tc.desc: Test.
134 * @tc.type: FUNC
135 */
136 HWTEST_F(NativeEngineTest, TimerTest005, testing::ext::TestSize.Level0)
137 {
138 napi_env env = (napi_env)engine_;
139 size_t argc = 2;
140 NativeValue* nativeMessage0 = engine_->CreateFunction("callback", strlen("callback"),
141 TimerCallback, nullptr);
142 int32_t number = -50.0; // Random number
143 NativeValue* nativeMessage1 = engine_->CreateNumber(number);
144 NativeValue* argv[] = {nativeMessage0, nativeMessage1};
145 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv); // timeout < 0
146 napi_value tId = TimerTest::SetTimeout(env, cbinfo);
147 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
148 }
149
150 /* @tc.name: settimeout
151 * @tc.desc: Test.
152 * @tc.type: FUNC
153 */
154 HWTEST_F(NativeEngineTest, TimerTest006, testing::ext::TestSize.Level0)
155 {
156 napi_env env = (napi_env)engine_;
157 size_t argc = 2;
158 NativeValue* nativeMessage0 = engine_->CreateFunction("callback", strlen("callback"),
159 TimerCallback, nullptr);
160 std::string message = "50";
161 NativeValue* nativeMessage1 = engine_->CreateString(message.c_str(), message.length());
162 NativeValue* argv[] = {nativeMessage0, nativeMessage1};
163 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv); // timeout is string
164 napi_value tId = TimerTest::SetTimeout(env, cbinfo);
165 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
166 }
167
168 /* @tc.name: ClearTimer
169 * @tc.desc: Test.
170 * @tc.type: FUNC
171 */
172 HWTEST_F(NativeEngineTest, TimerTest007, testing::ext::TestSize.Level0)
173 {
174 napi_env env = (napi_env)engine_;
175 size_t argc = 0;
176 NativeValue* argv[] = {nullptr};
177 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv); // no args
178 napi_value res = TimerTest::ClearTimer(env, cbinfo);
179 ASSERT_TRUE(res == nullptr);
180 }
181
182 /* @tc.name: ClearTimer
183 * @tc.desc: Test.
184 * @tc.type: FUNC
185 */
186 HWTEST_F(NativeEngineTest, TimerTest008, testing::ext::TestSize.Level0)
187 {
188 napi_env env = (napi_env)engine_;
189 size_t argc = 1;
190 std::string message = "50"; // Random number
191 NativeValue* nativeMessage = engine_->CreateString(message.c_str(), message.length());
192 NativeValue* argv[] = {nativeMessage};
193 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv); // first param should be number
194 napi_value res = TimerTest::ClearTimer(env, cbinfo);
195 ASSERT_TRUE(res == nullptr);
196 }
197
198 /* @tc.name: ClearTimer
199 * @tc.desc: Test.
200 * @tc.type: FUNC
201 */
202 HWTEST_F(NativeEngineTest, TimerTest009, testing::ext::TestSize.Level0)
203 {
204 napi_env env = (napi_env)engine_;
205 size_t argc = 1;
206 NativeValue* inputId = engine_->CreateNumber(50); // Random number
207 NativeValue* argv[] = {inputId};
208 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv); // timerId is inexistent
209 napi_value res = TimerTest::ClearTimer(env, cbinfo);
210 ASSERT_TRUE(res == nullptr);
211 }
212
213 /* @tc.name: setinteval
214 * @tc.desc: Test.
215 * @tc.type: FUNC
216 */
217 HWTEST_F(NativeEngineTest, TimerTest010, testing::ext::TestSize.Level0)
218 {
219 napi_env env = (napi_env)engine_;
220 size_t argc = 2;
221 NativeValue* nativeMessage0 = engine_->CreateNumber(5); // Random number
222 NativeValue* nativeMessage1 = engine_->CreateNumber(50); // Random number
223 NativeValue* argv1[] = {nativeMessage0, nativeMessage1};
224 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc, argv1); // uncallable
225 napi_value tId1 = TimerTest::SetInterval(env, cbinfo1);
226 ASSERT_CHECK_VALUE_TYPE(env, tId1, napi_undefined);
227
228 NativeValue* nativeMessage2 = engine_->CreateFunction("callback", strlen("callback"),
229 TimerCallback, nullptr);
230 NativeValue* argv2[] = {nativeMessage2, nativeMessage1};
231 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc, argv2);
232 napi_value tId2 = TimerTest::SetInterval(env, cbinfo2);
233 ASSERT_CHECK_VALUE_TYPE(env, tId2, napi_number);
234
235 int32_t number = -50.0; // Random number
236 NativeValue* nativeMessage3 = engine_->CreateNumber(number);
237 NativeValue* argv3[] = {nativeMessage2, nativeMessage3};
238 napi_callback_info cbinfo3 = napi_create_cbinfo(env, &argc, argv3); // timeout < 0
239 napi_value tId3 = TimerTest::SetTimeout(env, cbinfo3);
240 ASSERT_CHECK_VALUE_TYPE(env, tId3, napi_number);
241
242 std::string message = "50"; // Random number
243 NativeValue* nativeMessage4 = engine_->CreateString(message.c_str(), message.length());
244 NativeValue* argv4[] = {nativeMessage2, nativeMessage4};
245 napi_callback_info cbinfo4 = napi_create_cbinfo(env, &argc, argv4); // timeout is string
246 napi_value tId4 = TimerTest::SetInterval(env, cbinfo4);
247 ASSERT_CHECK_VALUE_TYPE(env, tId4, napi_number);
248
249 bool res0 = Timer::HasTimer(env);
250 ASSERT_TRUE(res0);
251
252 Timer::ClearEnvironmentTimer(env);
253 bool res1 = Timer::HasTimer(env);
254 ASSERT_TRUE(!res1);
255 }
256
257 /* @tc.name: settimeout
258 * @tc.desc: Test.
259 * @tc.type: FUNC
260 */
261 HWTEST_F(NativeEngineTest, TimerTest011, testing::ext::TestSize.Level0)
262 {
263 napi_env env = (napi_env)engine_;
264 size_t argc = 1; // argc = 1, timeout = 0
265 NativeValue* nativeMessage1 = engine_->CreateFunction("callback", strlen("callback"),
266 TimerCallback, nullptr);
267 NativeValue* argv[] = {nativeMessage1};
268 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
269 napi_value tId = TimerTest::SetTimeout(env, cbinfo);
270 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
271 }
272
273 /* @tc.name: settimeout
274 * @tc.desc: Test: callbackArgc > 0
275 * @tc.type: FUNC
276 */
277 HWTEST_F(NativeEngineTest, TimerTest012, testing::ext::TestSize.Level0)
278 {
279 napi_env env = (napi_env)engine_;
280 size_t argc = 3;
281 NativeValue* nativeMessage0 = engine_->CreateNumber(50); // Random number
282 NativeValue* nativeMessage1 = engine_->CreateFunction("callback", strlen("callback"),
283 TimerCallback, nullptr);
284 NativeValue* nativeMessage2 = engine_->CreateNumber(50); // Random number
285 NativeValue* argv[] = {nativeMessage1, nativeMessage0, nativeMessage2};
286 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
287 napi_value tId = TimerTest::SetTimeout(env, cbinfo);
288 ASSERT_CHECK_VALUE_TYPE(env, tId, napi_number);
289 }
290
291