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
napi_create_cbinfo(napi_env env,size_t * argc,NativeValue ** argv)99 napi_callback_info napi_create_cbinfo(napi_env env,
100 size_t* argc,
101 NativeValue** argv)
102 {
103 NativeCallbackInfo* info = new NativeCallbackInfo;
104
105 if (argv != nullptr && argc != nullptr) {
106 info->argc = *argc;
107 info->argv = argv;
108 return reinterpret_cast<napi_callback_info>(info);
109 }
110 return nullptr;
111 }
112 /* @tc.name: Console.Log/Console.Info/Console.debug/Console.error/Console.warn Test001
113 * @tc.desc: Test.
114 * @tc.type: FUNC
115 */
116 HWTEST_F(NativeEngineTest, ConsoleTest001, testing::ext::TestSize.Level0)
117 {
118 napi_env env = (napi_env)engine_;
119 size_t argc = 2;
120 std::string message = "console test %d";
121 NativeValue* nativeMessage0 = engine_->CreateString(message.c_str(), message.length());
122 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
123 NativeValue* argv[] = {nativeMessage0, nativeMessage1};
124
125 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
126 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo);
127 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
128 napi_value res1 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::DEBUG>(env, cbinfo);
129 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
130 napi_value res2 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::ERROR>(env, cbinfo);
131 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
132 napi_value res3 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::WARN>(env, cbinfo);
133 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
134 napi_value res4 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::FATAL>(env, cbinfo);
135 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
136 }
137
138 /* @tc.name: OutputFormat test Test002
139 * @tc.desc: Test.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(NativeEngineTest, ConsoleTest002, testing::ext::TestSize.Level0)
143 {
144 napi_env env = (napi_env)engine_;
145 size_t argc = 2;
146 std::string message0 = "console test %d";
147 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
148 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
149 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
150 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
151 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
152 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
153 }
154
155 /* @tc.name: OutputFormat test Test003
156 * @tc.desc: Test.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(NativeEngineTest, ConsoleTest003, testing::ext::TestSize.Level0)
160 {
161 napi_env env = (napi_env)engine_;
162 size_t argc = 2;
163 std::string message0 = "console test %s";
164 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
165 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
166 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
167 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
168 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
169 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
170 }
171
172 /* @tc.name: OutputFormat test Test004
173 * @tc.desc: Test.
174 * @tc.type: FUNC
175 */
176 HWTEST_F(NativeEngineTest, ConsoleTest004, testing::ext::TestSize.Level0)
177 {
178 napi_env env = (napi_env)engine_;
179 size_t argc = 2;
180 std::string message0 = "console test %j";
181 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
182 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
183 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
184 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
185 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
186 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
187 }
188
189 /* @tc.name: OutputFormat test Test005
190 * @tc.desc: Test.
191 * @tc.type: FUNC
192 */
193 HWTEST_F(NativeEngineTest, ConsoleTest005, testing::ext::TestSize.Level0)
194 {
195 napi_env env = (napi_env)engine_;
196 size_t argc = 2;
197 std::string message0 = "console test %O";
198 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
199 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
200 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
201 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
202 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
203 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
204 }
205
206 /* @tc.name: OutputFormat test Test006
207 * @tc.desc: Test.
208 * @tc.type: FUNC
209 */
210 HWTEST_F(NativeEngineTest, ConsoleTest006, testing::ext::TestSize.Level0)
211 {
212 napi_env env = (napi_env)engine_;
213 size_t argc = 2;
214 std::string message0 = "console test %o";
215 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
216 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
217 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
218 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
219 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
220 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
221 }
222
223 /* @tc.name: OutputFormat test Test007
224 * @tc.desc: Test.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(NativeEngineTest, ConsoleTest007, testing::ext::TestSize.Level0)
228 {
229 napi_env env = (napi_env)engine_;
230 size_t argc = 2;
231 std::string message0 = "console test %i";
232 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
233 NativeValue* nativeMessage1 = engine_->CreateNumber(5); // Random number
234 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
235 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
236 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
237 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
238 }
239
240 /* @tc.name: OutputFormat test Test005
241 * @tc.desc: Test.
242 * @tc.type: FUNC
243 */
244 HWTEST_F(NativeEngineTest, ConsoleTest008, testing::ext::TestSize.Level0)
245 {
246 napi_env env = (napi_env)engine_;
247 size_t argc = 2;
248 std::string message0 = "console test %f";
249 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
250 NativeValue* nativeMessage1 = engine_->CreateNumber(8); // Random number
251 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
252 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
253 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
254 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
255 }
256
257 /* @tc.name: OutputFormat test Test009
258 * @tc.desc: Test.
259 * @tc.type: FUNC
260 */
261 HWTEST_F(NativeEngineTest, ConsoleTest009, testing::ext::TestSize.Level0)
262 {
263 napi_env env = (napi_env)engine_;
264 size_t argc = 2;
265 std::string message0 = "console test %c";
266 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
267 NativeValue* nativeMessage1 = engine_->CreateNumber(8); // Random number
268 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
269 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
270 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
271 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
272 }
273
274 /* @tc.name: OutputFormat test Test010
275 * @tc.desc: Test.
276 * @tc.type: FUNC
277 */
278 HWTEST_F(NativeEngineTest, ConsoleTest010, testing::ext::TestSize.Level0)
279 {
280 napi_env env = (napi_env)engine_;
281 size_t argc = 2;
282 std::string message0 = "console test %%";
283 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
284 NativeValue* nativeMessage1 = engine_->CreateNumber(8); // Random number
285 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
286 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
287 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
288 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
289 }
290
291 /* @tc.name: OutputFormat test Test011
292 * @tc.desc: Test.
293 * @tc.type: FUNC
294 */
295 HWTEST_F(NativeEngineTest, ConsoleTest011, testing::ext::TestSize.Level0)
296 {
297 napi_env env = (napi_env)engine_;
298 size_t argc = 2;
299 std::string message0 = "console test %r";
300 NativeValue* nativeMessage0 = engine_->CreateString(message0.c_str(), message0.length());
301 NativeValue* nativeMessage1 = engine_->CreateNumber(8);
302 NativeValue* argv0[] = {nativeMessage0, nativeMessage1};
303 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc, argv0);
304 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo0);
305 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
306 }
307
308 /* @tc.name: Console.count/Console.countReset/
309 * @tc.desc: Test.
310 * @tc.type: FUNC
311 */
312 HWTEST_F(NativeEngineTest, ConsoleTest012, testing::ext::TestSize.Level0)
313 {
314 napi_env env = (napi_env)engine_;
315 size_t argc1 = 0;
316 NativeValue* argv1[] = {nullptr};
317 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc1, argv1);
318 napi_value res0 = ConsoleTest::Count(env, cbinfo1); // test default
319 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
320
321 size_t argc2 = 1;
322 std::string counterName = "abc"; // random value
323 NativeValue* nativeMessage = engine_->CreateString(counterName.c_str(), counterName.length());
324 NativeValue* argv2[] = {nativeMessage};
325 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc2, argv2);
326 napi_value res1 = ConsoleTest::Count(env, cbinfo2);
327 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
328 napi_value res2 = ConsoleTest::CountReset(env, cbinfo2);
329 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
330 napi_value res3 = ConsoleTest::CountReset(env, cbinfo2); // test re-reset
331 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
332 }
333
334 /* @tc.name: Console.Dir
335 * @tc.desc: Test.
336 * @tc.type: FUNC
337 */
338 HWTEST_F(NativeEngineTest, ConsoleTest013, testing::ext::TestSize.Level0)
339 {
340 napi_env env = (napi_env)engine_;
341
342 size_t argc = 0;
343 NativeValue* argv1[] = {nullptr};
344 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc, argv1);
345 napi_value res0 = ConsoleTest::Dir(env, cbinfo1);
346 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
347
348 argc = 1;
349 NativeValue* nativeMessage = engine_->CreateNumber(5);
350 NativeValue* argv2[] = {nativeMessage};
351 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc, argv2);
352 napi_value res1 = ConsoleTest::Dir(env, cbinfo2);
353 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
354 }
355
356 /* @tc.name: Console.Group/Console.GroupEnd
357 * @tc.desc: Test.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(NativeEngineTest, ConsoleTest014, testing::ext::TestSize.Level0)
361 {
362 napi_env env = (napi_env)engine_;
363 size_t argc = 0;
364 NativeValue* argv1[] = {nullptr};
365 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc, argv1);
366 napi_value res1 = ConsoleTest::Group(env, cbinfo1);
367 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
368
369 argc = 1;
370 NativeValue* nativeMessage = engine_->CreateNumber(5); // Random number
371 NativeValue* argv2[] = {nativeMessage, nativeMessage};
372 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc, argv2);
373 napi_value res2 = ConsoleTest::Group(env, cbinfo2);
374 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
375 napi_value res3 = ConsoleTest::GroupEnd(env, cbinfo2);
376 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
377 napi_value res4 = ConsoleTest::GroupEnd(env, cbinfo2); // test length < GROUPINDENTATION
378 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
379 napi_value res5 = ConsoleTest::GroupEnd(env, cbinfo2);
380 ASSERT_CHECK_VALUE_TYPE(env, res5, napi_undefined);
381 }
382
383 /* @tc.name: Console.Table
384 * @tc.desc: Test.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(NativeEngineTest, ConsoleTest015, testing::ext::TestSize.Level0)
388 {
389 napi_env env = (napi_env)engine_;
390
391 size_t argc = 0;
392 NativeValue* argv1[] = {nullptr};
393 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc, argv1);
394 napi_value res1 = ConsoleTest::Table(env, cbinfo1);
395 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
396
397 napi_value tabularData = nullptr;
398 uint32_t length0 = 2;
399 napi_create_array_with_length(env, length0, &tabularData);
400 napi_value number = nullptr;
401 napi_create_int32(env, 5, &number); // Random number
402 napi_value array1 = nullptr;
403 uint32_t length1 = 2;
404 napi_create_array_with_length(env, length1, &array1);
405 napi_set_element(env, array1, 0, number);
406 napi_set_element(env, array1, 1, number);
407 napi_set_named_property(env, tabularData, "number", array1);
408
409 napi_value array2 = nullptr;
410 uint32_t length2 = 2;
411 napi_create_array_with_length(env, length2, &array2);
412 napi_value strVal = StrToNapiValue(env, "name"); // random value
413 napi_set_element(env, array2, 0, strVal);
414 napi_set_element(env, array2, 1, strVal);
415 napi_set_named_property(env, tabularData, "string", array2);
416
417 argc = 1;
418 NativeValue* nativeMessage = reinterpret_cast<NativeValue*>(tabularData);
419 NativeValue* argv2[] = {nativeMessage};
420 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc, argv2);
421 napi_value res2 = ConsoleTest::Table(env, cbinfo2);
422 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
423 }
424
425 /* @tc.name: Console.Time/Timelog/TimeEnd
426 * @tc.desc: Test.
427 * @tc.type: FUNC
428 */
429 HWTEST_F(NativeEngineTest, ConsoleTest016, testing::ext::TestSize.Level0)
430 {
431 napi_env env = (napi_env)engine_;
432 size_t argc0 = 0;
433 NativeValue* argv0[] = {nullptr};
434 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc0, argv0);
435 napi_value res0 = ConsoleTest::Time(env, cbinfo0); // Test default
436 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
437
438 size_t argc1 = 1;
439 std::string timerName = "abc"; // Random value
440 NativeValue* nativeMessage = engine_->CreateString(timerName.c_str(), timerName.length());
441 NativeValue* argv1[] = {nativeMessage};
442 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc1, argv1);
443 napi_value res1 = ConsoleTest::Time(env, cbinfo1);
444 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
445 napi_value res2 = ConsoleTest::Time(env, cbinfo1); // Test repeat timerName, warn message check
446 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
447
448 size_t argc2 = 2;
449 std::string log = "timeLog"; // Random value
450 NativeValue* nativeMessage1 = engine_->CreateString(log.c_str(), log.length());
451 NativeValue* argv2[] = {nativeMessage, nativeMessage1};
452 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc2, argv2);
453 napi_value res3 = ConsoleTest::TimeLog(env, cbinfo2);
454 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
455 napi_value res4 = ConsoleTest::TimeEnd(env, cbinfo1); // Erase timer
456 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
457 napi_value res5 = ConsoleTest::TimeLog(env, cbinfo1); // Timer doesn't exists, warn message check
458 ASSERT_CHECK_VALUE_TYPE(env, res5, napi_undefined);
459 napi_value res6 = ConsoleTest::TimeEnd(env, cbinfo1); // Timer doesn't exists, warn message check
460 ASSERT_CHECK_VALUE_TYPE(env, res6, napi_undefined);
461 }
462
463 /* @tc.name: Console.Trace
464 * @tc.desc: Test.
465 * @tc.type: FUNC
466 */
467 HWTEST_F(NativeEngineTest, ConsoleTest017, testing::ext::TestSize.Level0)
468 {
469 napi_env env = (napi_env)engine_;
470
471 size_t argc = 0;
472 NativeValue* argv1[] = {nullptr};
473 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc, argv1);
474 napi_value res1 = ConsoleTest::Trace(env, cbinfo1);
475 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
476
477 argc = 1;
478 std::string message = "abc"; // Random value
479 NativeValue* nativeMessage = engine_->CreateString(message.c_str(), message.length());
480 NativeValue* argv2[] = {nativeMessage};
481 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc, argv2);
482 napi_value res2 = ConsoleTest::Trace(env, cbinfo2);
483 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
484 }
485
486 /* @tc.name: Console.Assert
487 * @tc.desc: Test.
488 * @tc.type: FUNC
489 */
490 HWTEST_F(NativeEngineTest, ConsoleTest018, testing::ext::TestSize.Level0)
491 {
492 napi_env env = (napi_env)engine_;
493
494 size_t argc0 = 0;
495 NativeValue* argv0[] = {nullptr}; // No input
496 napi_callback_info cbinfo0 = napi_create_cbinfo(env, &argc0, argv0);
497 napi_value res0 = ConsoleTest::Assert(env, cbinfo0);
498 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
499
500 size_t argc1 = 1;
501 NativeValue* nativeMessage0 = engine_->CreateBoolean(1); // True
502 NativeValue* argv1[] = {nativeMessage0};
503 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc1, argv1);
504 napi_value res1 = ConsoleTest::Assert(env, cbinfo1);
505 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
506
507 NativeValue* nativeMessage1 = engine_->CreateBoolean(0); // argc = 1 && False
508 NativeValue* argv2[] = {nativeMessage1};
509 napi_callback_info cbinfo2 = napi_create_cbinfo(env, &argc1, argv2);
510 napi_value res2 = ConsoleTest::Assert(env, cbinfo2);
511 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
512
513 size_t argc2 = 2;
514 NativeValue* nativeMessage3 = engine_->CreateBoolean(0); // False
515 std::string message = "log"; // Message to print
516 NativeValue* nativeMessage4 = engine_->CreateString(message.c_str(), message.length());
517 NativeValue* argv3[] = {nativeMessage3, nativeMessage4};
518 napi_callback_info cbinfo3 = napi_create_cbinfo(env, &argc2, argv3);
519 napi_value res3 = ConsoleTest::Assert(env, cbinfo3);
520 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
521 }
522
523 /* @tc.name: Init
524 * @tc.desc: Test.
525 * @tc.type: FUNC
526 */
527 HWTEST_F(NativeEngineTest, ConsoleTest019, testing::ext::TestSize.Level0)
528 {
529 napi_env env = (napi_env)engine_;
530 Console::InitConsoleModule(env);
531 bool res = 0;
532 napi_is_exception_pending(env, &res);
533 ASSERT_TRUE(!res);
534 }
535
536 /* @tc.name: PrintTime
537 * @tc.desc: Test.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(NativeEngineTest, ConsoleTest020, testing::ext::TestSize.Level0)
541 {
542 napi_env env = (napi_env)engine_;
543 std::string name = "Timer1";
544 std::string log = "log";
545
546 double ms = 50;
547 ConsoleTest::PrintTime(name, ms, log);
548 bool res0 = 0;
549 napi_is_exception_pending(env, &res0);
550 ASSERT_TRUE(!res0);
551
552 double seconds = 1 * 1000;
553 ConsoleTest::PrintTime(name, seconds, log);
554 bool res1 = 0;
555 napi_is_exception_pending(env, &res1);
556 ASSERT_TRUE(!res1);
557
558 double minutes = 60 * seconds;
559 ConsoleTest::PrintTime(name, minutes, log);
560 bool res2 = 0;
561 napi_is_exception_pending(env, &res2);
562 ASSERT_TRUE(!res2);
563
564 double hours = 60 * minutes;
565 ConsoleTest::PrintTime(name, hours, log);
566 bool res3 = 0;
567 napi_is_exception_pending(env, &res3);
568 ASSERT_TRUE(!res3);
569 }
570
571 /* @tc.name: Console.Log/Console.Info/Console.debug/Console.error/Console.warn
572 * @tc.desc: Test.no input
573 * @tc.type: FUNC
574 */
575 HWTEST_F(NativeEngineTest, ConsoleTest021, testing::ext::TestSize.Level0)
576 {
577 napi_env env = (napi_env)engine_;
578 size_t argc = 0;
579 NativeValue* argv[] = {nullptr};
580
581 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
582 napi_value res0 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>(env, cbinfo);
583 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
584 napi_value res1 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::DEBUG>(env, cbinfo);
585 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
586 napi_value res2 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::ERROR>(env, cbinfo);
587 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
588 napi_value res3 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::WARN>(env, cbinfo);
589 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
590 napi_value res4 = ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::FATAL>(env, cbinfo);
591 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
592 }