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_console.h"
21
22 using namespace Commonlibrary::Concurrent::Common;
23 using namespace OHOS::JsSysModule;
24
25 #define ASSERT_CHECK_CALL(call) \
26 { \
27 ASSERT_EQ(call, napi_ok); \
28 }
29
30 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
31 { \
32 napi_valuetype valueType = napi_undefined; \
33 ASSERT_TRUE((value) != nullptr); \
34 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
35 ASSERT_EQ(valueType, type); \
36 }
37
38 template<LogLevel LEVEL>
ConsoleLog(napi_env env,napi_callback_info info)39 napi_value ConsoleTest::ConsoleLog(napi_env env, napi_callback_info info)
40 {
41 return Console::ConsoleLog<LEVEL>(env, info);
42 }
Count(napi_env env,napi_callback_info info)43 napi_value ConsoleTest::Count(napi_env env, napi_callback_info info)
44 {
45 return Console::Count(env, info);
46 }
CountReset(napi_env env,napi_callback_info info)47 napi_value ConsoleTest::CountReset(napi_env env, napi_callback_info info)
48 {
49 return Console::CountReset(env, info);
50 }
Dir(napi_env env,napi_callback_info info)51 napi_value ConsoleTest::Dir(napi_env env, napi_callback_info info)
52 {
53 return Console::Dir(env, info);
54 }
Group(napi_env env,napi_callback_info info)55 napi_value ConsoleTest::Group(napi_env env, napi_callback_info info)
56 {
57 return Console::Group(env, info);
58 }
GroupEnd(napi_env env,napi_callback_info info)59 napi_value ConsoleTest::GroupEnd(napi_env env, napi_callback_info info)
60 {
61 return Console::GroupEnd(env, info);
62 }
Table(napi_env env,napi_callback_info info)63 napi_value ConsoleTest::Table(napi_env env, napi_callback_info info)
64 {
65 return Console::Table(env, info);
66 }
Time(napi_env env,napi_callback_info info)67 napi_value ConsoleTest::Time(napi_env env, napi_callback_info info)
68 {
69 return Console::Time(env, info);
70 }
TimeLog(napi_env env,napi_callback_info info)71 napi_value ConsoleTest::TimeLog(napi_env env, napi_callback_info info)
72 {
73 return Console::TimeLog(env, info);
74 }
TimeEnd(napi_env env,napi_callback_info info)75 napi_value ConsoleTest::TimeEnd(napi_env env, napi_callback_info info)
76 {
77 return Console::TimeEnd(env, info);
78 }
Trace(napi_env env,napi_callback_info info)79 napi_value ConsoleTest::Trace(napi_env env, napi_callback_info info)
80 {
81 return Console::Trace(env, info);
82 }
Assert(napi_env env,napi_callback_info info)83 napi_value ConsoleTest::Assert(napi_env env, napi_callback_info info)
84 {
85 return Console::Assert(env, info);
86 }
PrintTime(std::string timerName,double time,std::string & log)87 void ConsoleTest::PrintTime(std::string timerName, double time, std::string& log)
88 {
89 Console::PrintTime(timerName, time, log);
90 }
91
StrToNapiValue(napi_env env,const std::string & result)92 napi_value StrToNapiValue(napi_env env, const std::string &result)
93 {
94 napi_value output = nullptr;
95 napi_create_string_utf8(env, result.c_str(), result.size(), &output);
96 return output;
97 }
98
99 /* @tc.name: Console.Log/Console.Info/Console.debug/Console.error/Console.warn Test001
100 * @tc.desc: Test.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(NativeEngineTest, ConsoleTest001, testing::ext::TestSize.Level0)
104 {
105 napi_env env = (napi_env)engine_;
106 size_t argc = 2;
107 std::string message = "console test %d";
108 napi_value nativeMessage0 = nullptr;
109 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
110 napi_value nativeMessage1 = nullptr;
111 napi_create_uint32(env, 5, &nativeMessage1);
112 napi_value argv[] = {nativeMessage0, nativeMessage1};
113
114 std::string funcName = "ConsoleLog";
115 napi_value cb = nullptr;
116 napi_value res0 = nullptr;
117 napi_create_function(env, funcName.c_str(), funcName.size(),
118 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
119 napi_call_function(env, nullptr, cb, argc, argv, &res0);
120 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
121
122 cb = nullptr;
123 napi_value res1 = nullptr;
124 napi_create_function(env, funcName.c_str(), funcName.size(),
125 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::DEBUG>, nullptr, &cb);
126 napi_call_function(env, nullptr, cb, argc, argv, &res1);
127 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
128
129 cb = nullptr;
130 napi_value res2 = nullptr;
131 napi_create_function(env, funcName.c_str(), funcName.size(),
132 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::ERROR>, nullptr, &cb);
133 napi_call_function(env, nullptr, cb, argc, argv, &res2);
134 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
135
136 cb = nullptr;
137 napi_value res3 = nullptr;
138 napi_create_function(env, funcName.c_str(), funcName.size(),
139 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::WARN>, nullptr, &cb);
140 napi_call_function(env, nullptr, cb, argc, argv, &res3);
141 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
142
143 cb = nullptr;
144 napi_value res4 = nullptr;
145 napi_create_function(env, funcName.c_str(), funcName.size(),
146 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::FATAL>, nullptr, &cb);
147 napi_call_function(env, nullptr, cb, argc, argv, &res4);
148 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
149 }
150
151 /* @tc.name: OutputFormat test Test002
152 * @tc.desc: Test.
153 * @tc.type: FUNC
154 */
155 HWTEST_F(NativeEngineTest, ConsoleTest002, testing::ext::TestSize.Level0)
156 {
157 napi_env env = (napi_env)engine_;
158 size_t argc = 2;
159 napi_value res0 = nullptr;
160 std::string funcName = "ConsoleLog";
161 napi_value cb = nullptr;
162 std::string message = "console test %d";
163 napi_value nativeMessage0 = nullptr;
164 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
165 napi_value nativeMessage1 = nullptr;
166 napi_create_uint32(env, 5, &nativeMessage1);
167 napi_value argv[] = {nativeMessage0, nativeMessage1};
168
169 napi_create_function(env, funcName.c_str(), funcName.size(),
170 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
171 napi_call_function(env, nullptr, cb, argc, argv, &res0);
172 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
173 }
174
175 /* @tc.name: OutputFormat test Test003
176 * @tc.desc: Test.
177 * @tc.type: FUNC
178 */
179 HWTEST_F(NativeEngineTest, ConsoleTest003, testing::ext::TestSize.Level0)
180 {
181 napi_env env = (napi_env)engine_;
182 size_t argc = 2;
183 napi_value res0 = nullptr;
184 std::string funcName = "ConsoleLog";
185 napi_value cb = nullptr;
186 std::string message = "console test %s";
187 napi_value nativeMessage0 = nullptr;
188 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
189 napi_value nativeMessage1 = nullptr;
190 napi_create_uint32(env, 5, &nativeMessage1);
191 napi_value argv[] = {nativeMessage0, nativeMessage1};
192
193 napi_create_function(env, funcName.c_str(), funcName.size(),
194 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
195 napi_call_function(env, nullptr, cb, argc, argv, &res0);
196 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
197 }
198
199 /* @tc.name: OutputFormat test Test004
200 * @tc.desc: Test.
201 * @tc.type: FUNC
202 */
203 HWTEST_F(NativeEngineTest, ConsoleTest004, testing::ext::TestSize.Level0)
204 {
205 napi_env env = (napi_env)engine_;
206 size_t argc = 2;
207 napi_value res0 = nullptr;
208 std::string funcName = "ConsoleLog";
209 napi_value cb = nullptr;
210 std::string message = "console test %j";
211 napi_value nativeMessage0 = nullptr;
212 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
213 napi_value nativeMessage1 = nullptr;
214 napi_create_uint32(env, 5, &nativeMessage1);
215 napi_value argv[] = {nativeMessage0, nativeMessage1};
216
217 napi_create_function(env, funcName.c_str(), funcName.size(),
218 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
219 napi_call_function(env, nullptr, cb, argc, argv, &res0);
220 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
221 }
222
223 /* @tc.name: OutputFormat test Test005
224 * @tc.desc: Test.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(NativeEngineTest, ConsoleTest005, testing::ext::TestSize.Level0)
228 {
229 napi_env env = (napi_env)engine_;
230 size_t argc = 2;
231 napi_value res0 = nullptr;
232 std::string funcName = "ConsoleLog";
233 napi_value cb = nullptr;
234 std::string message = "console test %O";
235 napi_value nativeMessage0 = nullptr;
236 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
237 napi_value nativeMessage1 = nullptr;
238 napi_create_uint32(env, 5, &nativeMessage1);
239 napi_value argv[] = {nativeMessage0, nativeMessage1};
240 napi_create_function(env, funcName.c_str(), funcName.size(),
241 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
242 napi_call_function(env, nullptr, cb, argc, argv, &res0);
243 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
244 }
245
246 /* @tc.name: OutputFormat test Test006
247 * @tc.desc: Test.
248 * @tc.type: FUNC
249 */
250 HWTEST_F(NativeEngineTest, ConsoleTest006, testing::ext::TestSize.Level0)
251 {
252 napi_env env = (napi_env)engine_;
253 size_t argc = 2;
254 napi_value res0 = nullptr;
255 std::string funcName = "ConsoleLog";
256 napi_value cb = nullptr;
257 std::string message = "console test %o";
258 napi_value nativeMessage0 = nullptr;
259 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
260 napi_value nativeMessage1 = nullptr;
261 napi_create_uint32(env, 5, &nativeMessage1);
262 napi_value argv[] = {nativeMessage0, nativeMessage1};
263
264 napi_create_function(env, funcName.c_str(), funcName.size(),
265 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
266 napi_call_function(env, nullptr, cb, argc, argv, &res0);
267 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
268 }
269
270 /* @tc.name: OutputFormat test Test007
271 * @tc.desc: Test.
272 * @tc.type: FUNC
273 */
274 HWTEST_F(NativeEngineTest, ConsoleTest007, testing::ext::TestSize.Level0)
275 {
276 napi_env env = (napi_env)engine_;
277 size_t argc = 2;
278 napi_value res0 = nullptr;
279 std::string funcName = "ConsoleLog";
280 napi_value cb = nullptr;
281 std::string message = "console test %i";
282 napi_value nativeMessage0 = nullptr;
283 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
284 napi_value nativeMessage1 = nullptr;
285 napi_create_uint32(env, 5, &nativeMessage1);
286 napi_value argv[] = {nativeMessage0, nativeMessage1};
287
288 napi_create_function(env, funcName.c_str(), funcName.size(),
289 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
290 napi_call_function(env, nullptr, cb, argc, argv, &res0);
291 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
292 }
293
294 /* @tc.name: OutputFormat test Test005
295 * @tc.desc: Test.
296 * @tc.type: FUNC
297 */
298 HWTEST_F(NativeEngineTest, ConsoleTest008, testing::ext::TestSize.Level0)
299 {
300 napi_env env = (napi_env)engine_;
301 size_t argc = 2;
302 napi_value res0 = nullptr;
303 std::string funcName = "ConsoleLog";
304 napi_value cb = nullptr;
305 std::string message = "console test %f";
306 napi_value nativeMessage0 = nullptr;
307 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
308 napi_value nativeMessage1 = nullptr;
309 napi_create_uint32(env, 8, &nativeMessage1);
310 napi_value argv[] = {nativeMessage0, nativeMessage1};
311
312 napi_create_function(env, funcName.c_str(), funcName.size(),
313 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
314 napi_call_function(env, nullptr, cb, argc, argv, &res0);
315 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
316 }
317
318 /* @tc.name: OutputFormat test Test009
319 * @tc.desc: Test.
320 * @tc.type: FUNC
321 */
322 HWTEST_F(NativeEngineTest, ConsoleTest009, testing::ext::TestSize.Level0)
323 {
324 napi_env env = (napi_env)engine_;
325 size_t argc = 2;
326 napi_value res0 = nullptr;
327 std::string funcName = "ConsoleLog";
328 napi_value cb = nullptr;
329 std::string message = "console test %c";
330 napi_value nativeMessage0 = nullptr;
331 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
332 napi_value nativeMessage1 = nullptr;
333 napi_create_uint32(env, 5, &nativeMessage1);
334 napi_value argv[] = {nativeMessage0, nativeMessage1};
335
336 napi_create_function(env, funcName.c_str(), funcName.size(),
337 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
338 napi_call_function(env, nullptr, cb, argc, argv, &res0);
339 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
340 }
341
342 /* @tc.name: OutputFormat test Test010
343 * @tc.desc: Test.
344 * @tc.type: FUNC
345 */
346 HWTEST_F(NativeEngineTest, ConsoleTest010, testing::ext::TestSize.Level0)
347 {
348 napi_env env = (napi_env)engine_;
349 size_t argc = 2;
350 napi_value res0 = nullptr;
351 std::string funcName = "ConsoleLog";
352 napi_value cb = nullptr;
353 std::string message = "console test %%";
354 napi_value nativeMessage0 = nullptr;
355 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
356 napi_value nativeMessage1 = nullptr;
357 napi_create_uint32(env, 5, &nativeMessage1);
358 napi_value argv[] = {nativeMessage0, nativeMessage1};
359
360 napi_create_function(env, funcName.c_str(), funcName.size(),
361 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
362 napi_call_function(env, nullptr, cb, argc, argv, &res0);
363 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
364 }
365
366 /* @tc.name: OutputFormat test Test011
367 * @tc.desc: Test.
368 * @tc.type: FUNC
369 */
370 HWTEST_F(NativeEngineTest, ConsoleTest011, testing::ext::TestSize.Level0)
371 {
372 napi_env env = (napi_env)engine_;
373 size_t argc = 2;
374 napi_value res0 = nullptr;
375 std::string funcName = "ConsoleLog";
376 napi_value cb = nullptr;
377 std::string message = "console test %r";
378 napi_value nativeMessage0 = nullptr;
379 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
380 napi_value nativeMessage1 = nullptr;
381 napi_create_uint32(env, 8, &nativeMessage1);
382 napi_value argv[] = {nativeMessage0, nativeMessage1};
383
384 napi_create_function(env, funcName.c_str(), funcName.size(),
385 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
386 napi_call_function(env, nullptr, cb, argc, argv, &res0);
387 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
388 }
389
390 /* @tc.name: Console.count/Console.countReset/
391 * @tc.desc: Test.
392 * @tc.type: FUNC
393 */
394 HWTEST_F(NativeEngineTest, ConsoleTest012, testing::ext::TestSize.Level0)
395 {
396 napi_env env = (napi_env)engine_;
397 size_t argc = 0;
398 napi_value res = nullptr;
399 std::string funcName = "Count";
400 napi_value argv[] = {nullptr};
401 napi_value cb = nullptr;
402
403 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Count, nullptr, &cb);
404 napi_call_function(env, nullptr, cb, argc, argv, &res);
405 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
406
407 size_t argc2 = 1;
408 std::string message = "abc"; // random value
409 napi_value nativeMessage0 = nullptr;
410 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
411 napi_value argv2[] = {nativeMessage0};
412 cb = nullptr;
413 napi_value res0 = nullptr;
414 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Count, nullptr, &cb);
415 napi_call_function(env, nullptr, cb, argc2, argv2, &res0);
416 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
417
418 cb = nullptr;
419 funcName = "CountReset";
420 napi_value res1 = nullptr;
421 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::CountReset, nullptr, &cb);
422 napi_call_function(env, nullptr, cb, argc2, argv2, &res1);
423 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
424
425 cb = nullptr;
426 funcName = "CountReset";
427 napi_value res2 = nullptr;
428 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::CountReset, nullptr, &cb);
429 napi_call_function(env, nullptr, cb, argc2, argv2, &res2);
430 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
431 }
432
433 /* @tc.name: Console.Dir
434 * @tc.desc: Test.
435 * @tc.type: FUNC
436 */
437 HWTEST_F(NativeEngineTest, ConsoleTest013, testing::ext::TestSize.Level0)
438 {
439 napi_env env = (napi_env)engine_;
440 size_t argc = 0;
441 napi_value res0 = nullptr;
442 std::string funcName = "Dir";
443 napi_value argv[] = {nullptr};
444 napi_value cb = nullptr;
445
446 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Dir, nullptr, &cb);
447 napi_call_function(env, nullptr, cb, argc, argv, &res0);
448 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
449
450 argc = 1;
451 napi_value res1 = nullptr;
452 napi_value nativeMessage = nullptr;
453 napi_create_uint32(env, 5, &nativeMessage);
454 napi_value argv2[] = {nativeMessage};
455 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Dir, nullptr, &cb);
456 napi_call_function(env, nullptr, cb, argc, argv2, &res1);
457 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
458 }
459
460 /* @tc.name: Console.Group/Console.GroupEnd
461 * @tc.desc: Test.
462 * @tc.type: FUNC
463 */
464 HWTEST_F(NativeEngineTest, ConsoleTest014, testing::ext::TestSize.Level0)
465 {
466 napi_env env = (napi_env)engine_;
467 size_t argc = 0;
468 napi_value res0 = nullptr;
469 std::string funcName = "Group";
470 napi_value argv1[] = {nullptr};
471 napi_value cb = nullptr;
472
473 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Group, nullptr, &cb);
474 napi_call_function(env, nullptr, cb, argc, argv1, &res0);
475 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
476
477 argc = 1;
478 napi_value nativeMessage = nullptr;
479 napi_create_uint32(env, 5, &nativeMessage);
480 napi_value argv[] = {nativeMessage, nativeMessage};
481
482 funcName = "Group";
483 cb = nullptr;
484 napi_value res1 = nullptr;
485 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Group, nullptr, &cb);
486 napi_call_function(env, nullptr, cb, argc, argv, &res1);
487 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
488
489 funcName = "GroupEnd";
490 cb = nullptr;
491 napi_value res2 = nullptr;
492 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Group, nullptr, &cb);
493 napi_call_function(env, nullptr, cb, argc, argv, &res2);
494 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
495
496 funcName = "GroupEnd";
497 cb = nullptr;
498 napi_value res3 = nullptr;
499 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Group, nullptr, &cb);
500 napi_call_function(env, nullptr, cb, argc, argv, &res3);
501 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
502 }
503
504 /* @tc.name: Console.Table
505 * @tc.desc: Test.
506 * @tc.type: FUNC
507 */
508 HWTEST_F(NativeEngineTest, ConsoleTest015, testing::ext::TestSize.Level0)
509 {
510 napi_env env = (napi_env)engine_;
511 napi_value res0 = nullptr;
512 size_t argc = 0;
513 std::string funcName = "Table";
514 napi_value argv[] = {nullptr};
515 napi_value cb = nullptr;
516 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Table, nullptr, &cb);
517 napi_call_function(env, nullptr, cb, argc, argv, &res0);
518 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
519
520 napi_value tabularData = nullptr;
521 uint32_t length0 = 2;
522 napi_create_array_with_length(env, length0, &tabularData);
523 napi_value number = nullptr;
524 napi_create_int32(env, 5, &number); // Random number
525 napi_value array1 = nullptr;
526 uint32_t length1 = 2;
527 napi_create_array_with_length(env, length1, &array1);
528 napi_set_element(env, array1, 0, number);
529 napi_set_element(env, array1, 1, number);
530 napi_set_named_property(env, tabularData, "number", array1);
531
532 napi_value array2 = nullptr;
533 uint32_t length2 = 2;
534 napi_create_array_with_length(env, length2, &array2);
535 napi_value strVal = StrToNapiValue(env, "name"); // random value
536 napi_set_element(env, array2, 0, strVal);
537 napi_set_element(env, array2, 1, strVal);
538 napi_set_named_property(env, tabularData, "string", array2);
539
540 argc = 1;
541 napi_value argv2[] = {tabularData};
542 napi_value res3 = nullptr;
543 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Table, nullptr, &cb);
544 napi_call_function(env, nullptr, cb, argc, argv2, &res3);
545 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
546 }
547
548 /* @tc.name: Console.Time/Timelog/TimeEnd
549 * @tc.desc: Test.
550 * @tc.type: FUNC
551 */
552 HWTEST_F(NativeEngineTest, ConsoleTest016, testing::ext::TestSize.Level0)
553 {
554 napi_env env = (napi_env)engine_;
555 size_t argc = 0;
556 napi_value res0 = nullptr;
557 std::string funcName = "Time";
558 napi_value argv[] = {nullptr};
559 napi_value cb = nullptr;
560 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Time, nullptr, &cb);
561 napi_call_function(env, nullptr, cb, argc, argv, &res0);
562 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
563
564 size_t argc1 = 1;
565 std::string timerName = "abc"; // Random value
566 napi_value nativeMessage0 = nullptr;
567 napi_create_string_utf8(env, timerName.c_str(), timerName.length(), &nativeMessage0);
568 napi_value argv1[] = {nativeMessage0};
569
570 cb = nullptr;
571 napi_value res2 = nullptr;
572 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Time, nullptr, &cb);
573 napi_call_function(env, nullptr, cb, argc1, argv1, &res2);
574 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
575
576 cb = nullptr;
577 napi_value res3 = nullptr;
578 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Time, nullptr, &cb);
579 napi_call_function(env, nullptr, cb, argc1, argv1, &res3);
580 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
581
582 size_t argc2 = 2;
583 std::string log = "timeLog"; // Random value
584 napi_value nativeMessage1 = nullptr;
585 napi_create_string_utf8(env, log.c_str(), log.length(), &nativeMessage1);
586 napi_value argv2[] = {nativeMessage0, nativeMessage1};
587
588 cb = nullptr;
589 funcName = "TimeLog";
590 napi_value res = nullptr;
591 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeLog, nullptr, &cb);
592 napi_call_function(env, nullptr, cb, argc2, argv2, &res);
593 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
594
595 cb = nullptr;
596 funcName = "TimeEnd";
597 napi_value res4 = nullptr;
598 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeEnd, nullptr, &cb);
599 napi_call_function(env, nullptr, cb, argc2, argv2, &res4);
600 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
601
602 cb = nullptr;
603 funcName = "TimeLog";
604 napi_value res5 = nullptr;
605 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeLog, nullptr, &cb);
606 napi_call_function(env, nullptr, cb, argc2, argv2, &res5);
607 ASSERT_CHECK_VALUE_TYPE(env, res5, napi_undefined);
608
609 cb = nullptr;
610 funcName = "TimeEnd";
611 napi_value res6 = nullptr;
612 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeEnd, nullptr, &cb);
613 napi_call_function(env, nullptr, cb, argc2, argv2, &res6);
614 ASSERT_CHECK_VALUE_TYPE(env, res6, napi_undefined);
615 }
616
617 /* @tc.name: Console.Trace
618 * @tc.desc: Test.
619 * @tc.type: FUNC
620 */
621 HWTEST_F(NativeEngineTest, ConsoleTest017, testing::ext::TestSize.Level0)
622 {
623 napi_env env = (napi_env)engine_;
624 size_t argc = 0;
625 napi_value res0 = nullptr;
626 std::string funcName = "Trace";
627 napi_value argv[] = {nullptr};
628 napi_value cb = nullptr;
629 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Trace, nullptr, &cb);
630 napi_call_function(env, nullptr, cb, argc, argv, &res0);
631 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
632
633 argc = 1;
634 std::string message = "abc"; // Random value
635 napi_value nativeMessage1 = nullptr;
636 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage1);
637 napi_value argv2[] = {nativeMessage1};
638
639 cb = nullptr;
640 napi_value res1 = nullptr;
641 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Trace, nullptr, &cb);
642 napi_call_function(env, nullptr, cb, argc, argv2, &res1);
643 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
644 }
645
646 /* @tc.name: Console.Assert
647 * @tc.desc: Test.
648 * @tc.type: FUNC
649 */
650 HWTEST_F(NativeEngineTest, ConsoleTest018, testing::ext::TestSize.Level0)
651 {
652 napi_env env = (napi_env)engine_;
653 size_t argc = 0;
654 napi_value res0 = nullptr;
655 std::string funcName = "Assert";
656 napi_value argv[] = {nullptr};
657 napi_value cb = nullptr;
658 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
659 napi_call_function(env, nullptr, cb, argc, argv, &res0);
660 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
661
662 napi_value nativeMessage0 = nullptr;
663 size_t argc1 = 1;
664 napi_get_boolean(env, 1, &nativeMessage0);
665 napi_value argv1[] = {nativeMessage0};
666
667 cb = nullptr;
668 napi_value res1 = nullptr;
669 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
670 napi_call_function(env, nullptr, cb, argc1, argv1, &res1);
671 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
672
673 cb = nullptr;
674 napi_value res2 = nullptr;
675 napi_value nativeMessage1 = nullptr;
676 napi_get_boolean(env, 0, &nativeMessage1); // argc = 1 && False
677 napi_value argv2[] = {nativeMessage1};
678 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
679 napi_call_function(env, nullptr, cb, argc1, argv2, &res2);
680 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
681
682 size_t argc2 = 2;
683 cb = nullptr;
684 napi_value res3 = nullptr;
685 napi_value nativeMessage3 = nullptr;
686 napi_get_boolean(env, 0, &nativeMessage3); // && False
687 std::string message = "log"; // Message to print
688 napi_value nativeMessage4 = nullptr;
689 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage4);
690 napi_value argv3[] = {nativeMessage3, nativeMessage4};
691 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
692 napi_call_function(env, nullptr, cb, argc2, argv3, &res3);
693 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
694 }
695
696 /* @tc.name: Init
697 * @tc.desc: Test.
698 * @tc.type: FUNC
699 */
700 HWTEST_F(NativeEngineTest, ConsoleTest019, testing::ext::TestSize.Level0)
701 {
702 napi_env env = (napi_env)engine_;
703 Console::InitConsoleModule(env);
704 bool res = 0;
705 napi_is_exception_pending(env, &res);
706 ASSERT_TRUE(!res);
707 }
708
709 /* @tc.name: PrintTime
710 * @tc.desc: Test.
711 * @tc.type: FUNC
712 */
713 HWTEST_F(NativeEngineTest, ConsoleTest020, testing::ext::TestSize.Level0)
714 {
715 napi_env env = (napi_env)engine_;
716 std::string name = "Timer1";
717 std::string log = "log";
718
719 double ms = 50;
720 ConsoleTest::PrintTime(name, ms, log);
721 bool res0 = 0;
722 napi_is_exception_pending(env, &res0);
723 ASSERT_TRUE(!res0);
724
725 double seconds = 1 * 1000;
726 ConsoleTest::PrintTime(name, seconds, log);
727 bool res1 = 0;
728 napi_is_exception_pending(env, &res1);
729 ASSERT_TRUE(!res1);
730
731 double minutes = 60 * seconds;
732 ConsoleTest::PrintTime(name, minutes, log);
733 bool res2 = 0;
734 napi_is_exception_pending(env, &res2);
735 ASSERT_TRUE(!res2);
736
737 double hours = 60 * minutes;
738 ConsoleTest::PrintTime(name, hours, log);
739 bool res3 = 0;
740 napi_is_exception_pending(env, &res3);
741 ASSERT_TRUE(!res3);
742 }
743
744 /* @tc.name: Console.Log/Console.Info/Console.debug/Console.error/Console.warn
745 * @tc.desc: Test.no input
746 * @tc.type: FUNC
747 */
748 HWTEST_F(NativeEngineTest, ConsoleTest021, testing::ext::TestSize.Level0)
749 {
750 napi_env env = (napi_env)engine_;
751 size_t argc = 0;
752 napi_value argv[] = {nullptr};
753
754 std::string funcName = "ConsoleLog";
755 napi_value cb = nullptr;
756 napi_value res0 = nullptr;
757 napi_create_function(env, funcName.c_str(), funcName.size(),
758 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
759 napi_call_function(env, nullptr, cb, argc, argv, &res0);
760 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
761
762 cb = nullptr;
763 napi_value res1 = nullptr;
764 napi_create_function(env, funcName.c_str(), funcName.size(),
765 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::DEBUG>, nullptr, &cb);
766 napi_call_function(env, nullptr, cb, argc, argv, &res1);
767 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
768
769 cb = nullptr;
770 napi_value res2 = nullptr;
771 napi_create_function(env, funcName.c_str(), funcName.size(),
772 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::ERROR>, nullptr, &cb);
773 napi_call_function(env, nullptr, cb, argc, argv, &res2);
774 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
775
776 cb = nullptr;
777 napi_value res3 = nullptr;
778 napi_create_function(env, funcName.c_str(), funcName.size(),
779 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::WARN>, nullptr, &cb);
780 napi_call_function(env, nullptr, cb, argc, argv, &res3);
781 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
782
783 cb = nullptr;
784 napi_value res4 = nullptr;
785 napi_create_function(env, funcName.c_str(), funcName.size(),
786 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::FATAL>, nullptr, &cb);
787 napi_call_function(env, nullptr, cb, argc, argv, &res4);
788 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
789 }