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