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