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 "ark_native_engine.h"
17 #include "native_engine/native_value.h"
18 #include "napi/native_api.h"
19 #include "napi/native_node_api.h"
20 #include "test.h"
21 #include "test_console.h"
22
23 using namespace Commonlibrary::Concurrent::Common;
24 using namespace OHOS::JsSysModule;
25 using panda::RuntimeOption;
26
27 #define ASSERT_CHECK_CALL(call) \
28 { \
29 ASSERT_EQ(call, napi_ok); \
30 }
31
32 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
33 { \
34 napi_valuetype valueType = napi_undefined; \
35 ASSERT_TRUE((value) != nullptr); \
36 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
37 ASSERT_EQ(valueType, type); \
38 }
39
40 class NativeEngineProxy {
41 public:
NativeEngineProxy()42 NativeEngineProxy()
43 {
44 //Setup
45 RuntimeOption option;
46 option.SetGcType(RuntimeOption::GC_TYPE::GEN_GC);
47 const int64_t poolSize = 0x1000000;
48 option.SetGcPoolSize(poolSize);
49 option.SetLogLevel(RuntimeOption::LOG_LEVEL::ERROR);
50 option.SetDebuggerLibraryPath("");
51 vm_ = panda::JSNApi::CreateJSVM(option);
52 if (vm_ == nullptr) {
53 return;
54 }
55
56 engine_ = new ArkNativeEngine(vm_, nullptr);
57 Console::InitConsoleModule(reinterpret_cast<napi_env>(engine_));
58 }
59
~NativeEngineProxy()60 ~NativeEngineProxy()
61 {
62 delete engine_;
63 panda::JSNApi::DestroyJSVM(vm_);
64 }
65
operator -() const66 inline ArkNativeEngine* operator-() const
67 {
68 return engine_;
69 }
70
operator napi_env() const71 inline operator napi_env() const
72 {
73 return reinterpret_cast<napi_env>(engine_);
74 }
75
76 private:
77 EcmaVM* vm_ {nullptr};
78 ArkNativeEngine* engine_ {nullptr};
79 };
80
GetGlobalProperty(napi_env env,const char * name)81 napi_value GetGlobalProperty(napi_env env, const char *name)
82 {
83 napi_value global;
84 napi_get_global(env, &global);
85 napi_value console = nullptr;
86 napi_get_named_property(env, global, "console", &console);
87 napi_value value = nullptr;
88 napi_get_named_property(env, console, name, &value);
89 return value;
90 }
91
92 template<LogLevel LEVEL>
ConsoleLog(napi_env env,napi_callback_info info)93 napi_value ConsoleTest::ConsoleLog(napi_env env, napi_callback_info info)
94 {
95 return Console::ConsoleLog<LEVEL>(env, info);
96 }
Count(napi_env env,napi_callback_info info)97 napi_value ConsoleTest::Count(napi_env env, napi_callback_info info)
98 {
99 return Console::Count(env, info);
100 }
CountReset(napi_env env,napi_callback_info info)101 napi_value ConsoleTest::CountReset(napi_env env, napi_callback_info info)
102 {
103 return Console::CountReset(env, info);
104 }
Dir(napi_env env,napi_callback_info info)105 napi_value ConsoleTest::Dir(napi_env env, napi_callback_info info)
106 {
107 return Console::Dir(env, info);
108 }
Group(napi_env env,napi_callback_info info)109 napi_value ConsoleTest::Group(napi_env env, napi_callback_info info)
110 {
111 return Console::Group(env, info);
112 }
GroupEnd(napi_env env,napi_callback_info info)113 napi_value ConsoleTest::GroupEnd(napi_env env, napi_callback_info info)
114 {
115 return Console::GroupEnd(env, info);
116 }
Table(napi_env env,napi_callback_info info)117 napi_value ConsoleTest::Table(napi_env env, napi_callback_info info)
118 {
119 return Console::Table(env, info);
120 }
Time(napi_env env,napi_callback_info info)121 napi_value ConsoleTest::Time(napi_env env, napi_callback_info info)
122 {
123 return Console::Time(env, info);
124 }
TimeLog(napi_env env,napi_callback_info info)125 napi_value ConsoleTest::TimeLog(napi_env env, napi_callback_info info)
126 {
127 return Console::TimeLog(env, info);
128 }
TimeEnd(napi_env env,napi_callback_info info)129 napi_value ConsoleTest::TimeEnd(napi_env env, napi_callback_info info)
130 {
131 return Console::TimeEnd(env, info);
132 }
Trace(napi_env env,napi_callback_info info)133 napi_value ConsoleTest::Trace(napi_env env, napi_callback_info info)
134 {
135 return Console::Trace(env, info);
136 }
TraceHybridStack(napi_env env,napi_callback_info info)137 napi_value ConsoleTest::TraceHybridStack(napi_env env, napi_callback_info info)
138 {
139 return Console::TraceHybridStack(env, info);
140 }
Assert(napi_env env,napi_callback_info info)141 napi_value ConsoleTest::Assert(napi_env env, napi_callback_info info)
142 {
143 return Console::Assert(env, info);
144 }
PrintTime(std::string timerName,double time,std::string & log)145 void ConsoleTest::PrintTime(std::string timerName, double time, std::string& log)
146 {
147 Console::PrintTime(timerName, time, log);
148 }
149
StrToNapiValue(napi_env env,const std::string & result)150 napi_value StrToNapiValue(napi_env env, const std::string &result)
151 {
152 napi_value output = nullptr;
153 napi_create_string_utf8(env, result.c_str(), result.size(), &output);
154 return output;
155 }
156
SetGroupIndent(const std::string & newGroupIndent)157 void ConsoleTest::SetGroupIndent(const std::string& newGroupIndent)
158 {
159 Console::groupIndent = newGroupIndent;
160 }
161
GetGroupIndent()162 std::string ConsoleTest::GetGroupIndent()
163 {
164 return Console::groupIndent;
165 }
166
ParseLogContent(const std::vector<std::string> & params)167 std::string ConsoleTest::ParseLogContent(const std::vector<std::string>& params)
168 {
169 return Console::ParseLogContent(params);
170 }
171 /* @tc.name: Console.Log/Console.Info/Console.debug/Console.error/Console.warn Test001
172 * @tc.desc: Test.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(NativeEngineTest, ConsoleTest001, testing::ext::TestSize.Level0)
176 {
177 napi_env env = (napi_env)engine_;
178 size_t argc = 2;
179 std::string message = "console test %d";
180 napi_value nativeMessage0 = nullptr;
181 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
182 napi_value nativeMessage1 = nullptr;
183 napi_create_uint32(env, 5, &nativeMessage1);
184 napi_value argv[] = {nativeMessage0, nativeMessage1};
185
186 std::string funcName = "ConsoleLog";
187 napi_value cb = nullptr;
188 napi_value res0 = nullptr;
189 napi_create_function(env, funcName.c_str(), funcName.size(),
190 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
191 napi_call_function(env, nullptr, cb, argc, argv, &res0);
192 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
193
194 cb = nullptr;
195 napi_value res1 = nullptr;
196 napi_create_function(env, funcName.c_str(), funcName.size(),
197 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::DEBUG>, nullptr, &cb);
198 napi_call_function(env, nullptr, cb, argc, argv, &res1);
199 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
200
201 cb = nullptr;
202 napi_value res2 = nullptr;
203 napi_create_function(env, funcName.c_str(), funcName.size(),
204 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::ERROR>, nullptr, &cb);
205 napi_call_function(env, nullptr, cb, argc, argv, &res2);
206 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
207
208 cb = nullptr;
209 napi_value res3 = nullptr;
210 napi_create_function(env, funcName.c_str(), funcName.size(),
211 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::WARN>, nullptr, &cb);
212 napi_call_function(env, nullptr, cb, argc, argv, &res3);
213 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
214
215 cb = nullptr;
216 napi_value res4 = nullptr;
217 napi_create_function(env, funcName.c_str(), funcName.size(),
218 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::FATAL>, nullptr, &cb);
219 napi_call_function(env, nullptr, cb, argc, argv, &res4);
220 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
221 }
222
223 /* @tc.name: OutputFormat test Test002
224 * @tc.desc: Test.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(NativeEngineTest, ConsoleTest002, testing::ext::TestSize.Level0)
228 {
229 napi_env env = (napi_env)engine_;
230 size_t argc = 2;
231 napi_value res0 = nullptr;
232 std::string funcName = "ConsoleLog";
233 napi_value cb = nullptr;
234 std::string message = "console test %d";
235 napi_value nativeMessage0 = nullptr;
236 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
237 napi_value nativeMessage1 = nullptr;
238 napi_create_uint32(env, 5, &nativeMessage1);
239 napi_value argv[] = {nativeMessage0, nativeMessage1};
240
241 napi_create_function(env, funcName.c_str(), funcName.size(),
242 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
243 napi_call_function(env, nullptr, cb, argc, argv, &res0);
244 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
245 }
246
247 /* @tc.name: OutputFormat test Test003
248 * @tc.desc: Test.
249 * @tc.type: FUNC
250 */
251 HWTEST_F(NativeEngineTest, ConsoleTest003, testing::ext::TestSize.Level0)
252 {
253 napi_env env = (napi_env)engine_;
254 size_t argc = 2;
255 napi_value res0 = nullptr;
256 std::string funcName = "ConsoleLog";
257 napi_value cb = nullptr;
258 std::string message = "console test %s";
259 napi_value nativeMessage0 = nullptr;
260 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
261 napi_value nativeMessage1 = nullptr;
262 napi_create_uint32(env, 5, &nativeMessage1);
263 napi_value argv[] = {nativeMessage0, nativeMessage1};
264
265 napi_create_function(env, funcName.c_str(), funcName.size(),
266 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
267 napi_call_function(env, nullptr, cb, argc, argv, &res0);
268 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
269 }
270
271 /* @tc.name: OutputFormat test Test004
272 * @tc.desc: Test.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(NativeEngineTest, ConsoleTest004, testing::ext::TestSize.Level0)
276 {
277 napi_env env = (napi_env)engine_;
278 size_t argc = 2;
279 napi_value res0 = nullptr;
280 std::string funcName = "ConsoleLog";
281 napi_value cb = nullptr;
282 std::string message = "console test %j";
283 napi_value nativeMessage0 = nullptr;
284 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
285 napi_value nativeMessage1 = nullptr;
286 napi_create_uint32(env, 5, &nativeMessage1);
287 napi_value argv[] = {nativeMessage0, nativeMessage1};
288
289 napi_create_function(env, funcName.c_str(), funcName.size(),
290 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
291 napi_call_function(env, nullptr, cb, argc, argv, &res0);
292 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
293 }
294
295 /* @tc.name: OutputFormat test Test005
296 * @tc.desc: Test.
297 * @tc.type: FUNC
298 */
299 HWTEST_F(NativeEngineTest, ConsoleTest005, testing::ext::TestSize.Level0)
300 {
301 napi_env env = (napi_env)engine_;
302 size_t argc = 2;
303 napi_value res0 = nullptr;
304 std::string funcName = "ConsoleLog";
305 napi_value cb = nullptr;
306 std::string message = "console test %O";
307 napi_value nativeMessage0 = nullptr;
308 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
309 napi_value nativeMessage1 = nullptr;
310 napi_create_uint32(env, 5, &nativeMessage1);
311 napi_value argv[] = {nativeMessage0, nativeMessage1};
312 napi_create_function(env, funcName.c_str(), funcName.size(),
313 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
314 napi_call_function(env, nullptr, cb, argc, argv, &res0);
315 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
316 }
317
318 /* @tc.name: OutputFormat test Test006
319 * @tc.desc: Test.
320 * @tc.type: FUNC
321 */
322 HWTEST_F(NativeEngineTest, ConsoleTest006, testing::ext::TestSize.Level0)
323 {
324 napi_env env = (napi_env)engine_;
325 size_t argc = 2;
326 napi_value res0 = nullptr;
327 std::string funcName = "ConsoleLog";
328 napi_value cb = nullptr;
329 std::string message = "console test %o";
330 napi_value nativeMessage0 = nullptr;
331 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
332 napi_value nativeMessage1 = nullptr;
333 napi_create_uint32(env, 5, &nativeMessage1);
334 napi_value argv[] = {nativeMessage0, nativeMessage1};
335
336 napi_create_function(env, funcName.c_str(), funcName.size(),
337 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
338 napi_call_function(env, nullptr, cb, argc, argv, &res0);
339 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
340 }
341
342 /* @tc.name: OutputFormat test Test007
343 * @tc.desc: Test.
344 * @tc.type: FUNC
345 */
346 HWTEST_F(NativeEngineTest, ConsoleTest007, testing::ext::TestSize.Level0)
347 {
348 napi_env env = (napi_env)engine_;
349 size_t argc = 2;
350 napi_value res0 = nullptr;
351 std::string funcName = "ConsoleLog";
352 napi_value cb = nullptr;
353 std::string message = "console test %i";
354 napi_value nativeMessage0 = nullptr;
355 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
356 napi_value nativeMessage1 = nullptr;
357 napi_create_uint32(env, 5, &nativeMessage1);
358 napi_value argv[] = {nativeMessage0, nativeMessage1};
359
360 napi_create_function(env, funcName.c_str(), funcName.size(),
361 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
362 napi_call_function(env, nullptr, cb, argc, argv, &res0);
363 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
364 }
365
366 /* @tc.name: OutputFormat test Test005
367 * @tc.desc: Test.
368 * @tc.type: FUNC
369 */
370 HWTEST_F(NativeEngineTest, ConsoleTest008, testing::ext::TestSize.Level0)
371 {
372 napi_env env = (napi_env)engine_;
373 size_t argc = 2;
374 napi_value res0 = nullptr;
375 std::string funcName = "ConsoleLog";
376 napi_value cb = nullptr;
377 std::string message = "console test %f";
378 napi_value nativeMessage0 = nullptr;
379 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
380 napi_value nativeMessage1 = nullptr;
381 napi_create_uint32(env, 8, &nativeMessage1);
382 napi_value argv[] = {nativeMessage0, nativeMessage1};
383
384 napi_create_function(env, funcName.c_str(), funcName.size(),
385 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
386 napi_call_function(env, nullptr, cb, argc, argv, &res0);
387 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
388 }
389
390 /* @tc.name: OutputFormat test Test009
391 * @tc.desc: Test.
392 * @tc.type: FUNC
393 */
394 HWTEST_F(NativeEngineTest, ConsoleTest009, testing::ext::TestSize.Level0)
395 {
396 napi_env env = (napi_env)engine_;
397 size_t argc = 2;
398 napi_value res0 = nullptr;
399 std::string funcName = "ConsoleLog";
400 napi_value cb = nullptr;
401 std::string message = "console test %c";
402 napi_value nativeMessage0 = nullptr;
403 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
404 napi_value nativeMessage1 = nullptr;
405 napi_create_uint32(env, 5, &nativeMessage1);
406 napi_value argv[] = {nativeMessage0, nativeMessage1};
407
408 napi_create_function(env, funcName.c_str(), funcName.size(),
409 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
410 napi_call_function(env, nullptr, cb, argc, argv, &res0);
411 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
412 }
413
414 /* @tc.name: OutputFormat test Test010
415 * @tc.desc: Test.
416 * @tc.type: FUNC
417 */
418 HWTEST_F(NativeEngineTest, ConsoleTest010, testing::ext::TestSize.Level0)
419 {
420 napi_env env = (napi_env)engine_;
421 size_t argc = 2;
422 napi_value res0 = nullptr;
423 std::string funcName = "ConsoleLog";
424 napi_value cb = nullptr;
425 std::string message = "console test %%";
426 napi_value nativeMessage0 = nullptr;
427 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
428 napi_value nativeMessage1 = nullptr;
429 napi_create_uint32(env, 5, &nativeMessage1);
430 napi_value argv[] = {nativeMessage0, nativeMessage1};
431
432 napi_create_function(env, funcName.c_str(), funcName.size(),
433 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
434 napi_call_function(env, nullptr, cb, argc, argv, &res0);
435 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
436 }
437
438 /* @tc.name: OutputFormat test Test011
439 * @tc.desc: Test.
440 * @tc.type: FUNC
441 */
442 HWTEST_F(NativeEngineTest, ConsoleTest011, testing::ext::TestSize.Level0)
443 {
444 napi_env env = (napi_env)engine_;
445 size_t argc = 2;
446 napi_value res0 = nullptr;
447 std::string funcName = "ConsoleLog";
448 napi_value cb = nullptr;
449 std::string message = "console test %r";
450 napi_value nativeMessage0 = nullptr;
451 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
452 napi_value nativeMessage1 = nullptr;
453 napi_create_uint32(env, 8, &nativeMessage1);
454 napi_value argv[] = {nativeMessage0, nativeMessage1};
455
456 napi_create_function(env, funcName.c_str(), funcName.size(),
457 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
458 napi_call_function(env, nullptr, cb, argc, argv, &res0);
459 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
460 }
461
462 /* @tc.name: Console.count/Console.countReset/
463 * @tc.desc: Test.
464 * @tc.type: FUNC
465 */
466 HWTEST_F(NativeEngineTest, ConsoleTest012, testing::ext::TestSize.Level0)
467 {
468 napi_env env = (napi_env)engine_;
469 size_t argc = 0;
470 napi_value res = nullptr;
471 std::string funcName = "Count";
472 napi_value argv[] = {nullptr};
473 napi_value cb = nullptr;
474
475 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Count, nullptr, &cb);
476 napi_call_function(env, nullptr, cb, argc, argv, &res);
477 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
478
479 size_t argc2 = 1;
480 std::string message = "abc"; // random value
481 napi_value nativeMessage0 = nullptr;
482 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
483 napi_value argv2[] = {nativeMessage0};
484 cb = nullptr;
485 napi_value res0 = nullptr;
486 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Count, nullptr, &cb);
487 napi_call_function(env, nullptr, cb, argc2, argv2, &res0);
488 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
489
490 cb = nullptr;
491 funcName = "CountReset";
492 napi_value res1 = nullptr;
493 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::CountReset, nullptr, &cb);
494 napi_call_function(env, nullptr, cb, argc2, argv2, &res1);
495 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
496
497 cb = nullptr;
498 funcName = "CountReset";
499 napi_value res2 = nullptr;
500 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::CountReset, nullptr, &cb);
501 napi_call_function(env, nullptr, cb, argc2, argv2, &res2);
502 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
503 }
504
505 /* @tc.name: Console.Dir
506 * @tc.desc: Test.
507 * @tc.type: FUNC
508 */
509 HWTEST_F(NativeEngineTest, ConsoleTest013, testing::ext::TestSize.Level0)
510 {
511 napi_env env = (napi_env)engine_;
512 size_t argc = 0;
513 napi_value res0 = nullptr;
514 std::string funcName = "Dir";
515 napi_value argv[] = {nullptr};
516 napi_value cb = nullptr;
517
518 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Dir, nullptr, &cb);
519 napi_call_function(env, nullptr, cb, argc, argv, &res0);
520 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
521
522 argc = 1;
523 napi_value res1 = nullptr;
524 napi_value nativeMessage = nullptr;
525 napi_create_uint32(env, 5, &nativeMessage);
526 napi_value argv2[] = {nativeMessage};
527 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Dir, nullptr, &cb);
528 napi_call_function(env, nullptr, cb, argc, argv2, &res1);
529 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
530 }
531
532 /* @tc.name: Console.Group/Console.GroupEnd
533 * @tc.desc: Test.
534 * @tc.type: FUNC
535 */
536 HWTEST_F(NativeEngineTest, ConsoleTest014, testing::ext::TestSize.Level0)
537 {
538 napi_env env = (napi_env)engine_;
539 size_t argc = 0;
540 napi_value res0 = nullptr;
541 std::string funcName = "Group";
542 napi_value argv1[] = {nullptr};
543 napi_value cb = nullptr;
544
545 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Group, nullptr, &cb);
546 napi_call_function(env, nullptr, cb, argc, argv1, &res0);
547 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
548
549 argc = 1;
550 napi_value nativeMessage = nullptr;
551 napi_create_uint32(env, 5, &nativeMessage);
552 napi_value argv[] = {nativeMessage, nativeMessage};
553
554 funcName = "Group";
555 cb = nullptr;
556 napi_value res1 = nullptr;
557 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Group, nullptr, &cb);
558 napi_call_function(env, nullptr, cb, argc, argv, &res1);
559 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
560
561 funcName = "GroupEnd";
562 cb = nullptr;
563 napi_value res2 = nullptr;
564 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::GroupEnd, nullptr, &cb);
565 napi_call_function(env, nullptr, cb, argc, argv, &res2);
566 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
567
568 funcName = "GroupEnd";
569 cb = nullptr;
570 napi_value res3 = nullptr;
571 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::GroupEnd, nullptr, &cb);
572 napi_call_function(env, nullptr, cb, argc, argv, &res3);
573 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
574 }
575
576 /* @tc.name: Console.Table
577 * @tc.desc: Test.
578 * @tc.type: FUNC
579 */
580 HWTEST_F(NativeEngineTest, ConsoleTest015, testing::ext::TestSize.Level0)
581 {
582 napi_env env = (napi_env)engine_;
583 napi_value res0 = nullptr;
584 size_t argc = 0;
585 std::string funcName = "Table";
586 napi_value argv[] = {nullptr};
587 napi_value cb = nullptr;
588 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Table, nullptr, &cb);
589 napi_call_function(env, nullptr, cb, argc, argv, &res0);
590 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
591
592 napi_value tabularData = nullptr;
593 uint32_t length0 = 2;
594 napi_create_array_with_length(env, length0, &tabularData);
595 napi_value number = nullptr;
596 napi_create_int32(env, 5, &number); // Random number
597 napi_value array1 = nullptr;
598 uint32_t length1 = 2;
599 napi_create_array_with_length(env, length1, &array1);
600 napi_set_element(env, array1, 0, number);
601 napi_set_element(env, array1, 1, number);
602 napi_set_named_property(env, tabularData, "number", array1);
603
604 napi_value array2 = nullptr;
605 uint32_t length2 = 2;
606 napi_create_array_with_length(env, length2, &array2);
607 napi_value strVal = StrToNapiValue(env, "name"); // random value
608 napi_set_element(env, array2, 0, strVal);
609 napi_set_element(env, array2, 1, strVal);
610 napi_set_named_property(env, tabularData, "string", array2);
611
612 argc = 1;
613 napi_value argv2[] = {tabularData};
614 napi_value res3 = nullptr;
615 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Table, nullptr, &cb);
616 napi_call_function(env, nullptr, cb, argc, argv2, &res3);
617 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
618 }
619
620 /* @tc.name: Console.Time/Timelog/TimeEnd
621 * @tc.desc: Test.
622 * @tc.type: FUNC
623 */
624 HWTEST_F(NativeEngineTest, ConsoleTest016, testing::ext::TestSize.Level0)
625 {
626 napi_env env = (napi_env)engine_;
627 size_t argc = 0;
628 napi_value res0 = nullptr;
629 std::string funcName = "Time";
630 napi_value argv[] = {nullptr};
631 napi_value cb = nullptr;
632 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Time, nullptr, &cb);
633 napi_call_function(env, nullptr, cb, argc, argv, &res0);
634 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
635
636 size_t argc1 = 1;
637 std::string timerName = "abc"; // Random value
638 napi_value nativeMessage0 = nullptr;
639 napi_create_string_utf8(env, timerName.c_str(), timerName.length(), &nativeMessage0);
640 napi_value argv1[] = {nativeMessage0};
641
642 cb = nullptr;
643 napi_value res2 = nullptr;
644 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Time, nullptr, &cb);
645 napi_call_function(env, nullptr, cb, argc1, argv1, &res2);
646 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
647
648 cb = nullptr;
649 napi_value res3 = nullptr;
650 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Time, nullptr, &cb);
651 napi_call_function(env, nullptr, cb, argc1, argv1, &res3);
652 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
653
654 size_t argc2 = 2;
655 std::string log = "timeLog"; // Random value
656 napi_value nativeMessage1 = nullptr;
657 napi_create_string_utf8(env, log.c_str(), log.length(), &nativeMessage1);
658 napi_value argv2[] = {nativeMessage0, nativeMessage1};
659
660 cb = nullptr;
661 funcName = "TimeLog";
662 napi_value res = nullptr;
663 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeLog, nullptr, &cb);
664 napi_call_function(env, nullptr, cb, argc2, argv2, &res);
665 ASSERT_CHECK_VALUE_TYPE(env, res, napi_undefined);
666
667 cb = nullptr;
668 funcName = "TimeEnd";
669 napi_value res4 = nullptr;
670 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeEnd, nullptr, &cb);
671 napi_call_function(env, nullptr, cb, argc2, argv2, &res4);
672 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
673
674 cb = nullptr;
675 funcName = "TimeLog";
676 napi_value res5 = nullptr;
677 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeLog, nullptr, &cb);
678 napi_call_function(env, nullptr, cb, argc2, argv2, &res5);
679 ASSERT_CHECK_VALUE_TYPE(env, res5, napi_undefined);
680
681 cb = nullptr;
682 funcName = "TimeEnd";
683 napi_value res6 = nullptr;
684 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeEnd, nullptr, &cb);
685 napi_call_function(env, nullptr, cb, argc2, argv2, &res6);
686 ASSERT_CHECK_VALUE_TYPE(env, res6, napi_undefined);
687
688 size_t argc3 = 1;
689 napi_value nativeMessage2 = nullptr;
690 napi_value argv3[] = {nativeMessage2};
691 cb = nullptr;
692 funcName = "TimeEnd";
693 napi_value res7 = nullptr;
694 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TimeEnd, nullptr, &cb);
695 napi_call_function(env, nullptr, cb, argc3, argv3, &res7);
696 ASSERT_CHECK_VALUE_TYPE(env, res7, napi_undefined);
697 }
698
699 /* @tc.name: Console.Trace
700 * @tc.desc: Test.
701 * @tc.type: FUNC
702 */
703 HWTEST_F(NativeEngineTest, ConsoleTest017, testing::ext::TestSize.Level0)
704 {
705 napi_env env = (napi_env)engine_;
706 size_t argc = 0;
707 napi_value res0 = nullptr;
708 std::string funcName = "Trace";
709 napi_value argv[] = {nullptr};
710 napi_value cb = nullptr;
711 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Trace, nullptr, &cb);
712 napi_call_function(env, nullptr, cb, argc, argv, &res0);
713 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
714
715 argc = 1;
716 std::string message = "abc"; // Random value
717 napi_value nativeMessage1 = nullptr;
718 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage1);
719 napi_value argv2[] = {nativeMessage1};
720
721 cb = nullptr;
722 napi_value res1 = nullptr;
723 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Trace, nullptr, &cb);
724 napi_call_function(env, nullptr, cb, argc, argv2, &res1);
725 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
726 }
727
728 /* @tc.name: Console.Assert
729 * @tc.desc: Test.
730 * @tc.type: FUNC
731 */
732 HWTEST_F(NativeEngineTest, ConsoleTest018, testing::ext::TestSize.Level0)
733 {
734 napi_env env = (napi_env)engine_;
735 size_t argc = 0;
736 napi_value res0 = nullptr;
737 std::string funcName = "Assert";
738 napi_value argv[] = {nullptr};
739 napi_value cb = nullptr;
740 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
741 napi_call_function(env, nullptr, cb, argc, argv, &res0);
742 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
743
744 napi_value nativeMessage0 = nullptr;
745 size_t argc1 = 1;
746 napi_get_boolean(env, 1, &nativeMessage0);
747 napi_value argv1[] = {nativeMessage0};
748
749 cb = nullptr;
750 napi_value res1 = nullptr;
751 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
752 napi_call_function(env, nullptr, cb, argc1, argv1, &res1);
753 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
754
755 cb = nullptr;
756 napi_value res2 = nullptr;
757 napi_value nativeMessage1 = nullptr;
758 napi_get_boolean(env, 0, &nativeMessage1); // argc = 1 && False
759 napi_value argv2[] = {nativeMessage1};
760 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
761 napi_call_function(env, nullptr, cb, argc1, argv2, &res2);
762 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
763
764 size_t argc2 = 2;
765 cb = nullptr;
766 napi_value res3 = nullptr;
767 napi_value nativeMessage3 = nullptr;
768 napi_get_boolean(env, 0, &nativeMessage3); // && False
769 std::string message = "log"; // Message to print
770 napi_value nativeMessage4 = nullptr;
771 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage4);
772 napi_value argv3[] = {nativeMessage3, nativeMessage4};
773 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::Assert, nullptr, &cb);
774 napi_call_function(env, nullptr, cb, argc2, argv3, &res3);
775 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
776 }
777
778 /* @tc.name: Init
779 * @tc.desc: Test.
780 * @tc.type: FUNC
781 */
782 HWTEST_F(NativeEngineTest, ConsoleTest019, testing::ext::TestSize.Level0)
783 {
784 napi_env env = (napi_env)engine_;
785 Console::InitConsoleModule(env);
786 bool res = 0;
787 napi_is_exception_pending(env, &res);
788 ASSERT_TRUE(!res);
789 }
790
791 /* @tc.name: PrintTime
792 * @tc.desc: Test.
793 * @tc.type: FUNC
794 */
795 HWTEST_F(NativeEngineTest, ConsoleTest020, testing::ext::TestSize.Level0)
796 {
797 napi_env env = (napi_env)engine_;
798 std::string name = "Timer1";
799 std::string log = "log";
800
801 double ms = 50;
802 ConsoleTest::PrintTime(name, ms, log);
803 bool res0 = 0;
804 napi_is_exception_pending(env, &res0);
805 ASSERT_TRUE(!res0);
806
807 double seconds = 1 * 1000;
808 ConsoleTest::PrintTime(name, seconds, log);
809 bool res1 = 0;
810 napi_is_exception_pending(env, &res1);
811 ASSERT_TRUE(!res1);
812
813 double minutes = 60 * seconds;
814 ConsoleTest::PrintTime(name, minutes, log);
815 bool res2 = 0;
816 napi_is_exception_pending(env, &res2);
817 ASSERT_TRUE(!res2);
818
819 double hours = 60 * minutes;
820 ConsoleTest::PrintTime(name, hours, log);
821 bool res3 = 0;
822 napi_is_exception_pending(env, &res3);
823 ASSERT_TRUE(!res3);
824 }
825
826 /* @tc.name: Console.Log/Console.Info/Console.debug/Console.error/Console.warn
827 * @tc.desc: Test.no input
828 * @tc.type: FUNC
829 */
830 HWTEST_F(NativeEngineTest, ConsoleTest021, testing::ext::TestSize.Level0)
831 {
832 napi_env env = (napi_env)engine_;
833 size_t argc = 0;
834 napi_value argv[] = {nullptr};
835
836 std::string funcName = "ConsoleLog";
837 napi_value cb = nullptr;
838 napi_value res0 = nullptr;
839 napi_create_function(env, funcName.c_str(), funcName.size(),
840 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
841 napi_call_function(env, nullptr, cb, argc, argv, &res0);
842 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
843
844 cb = nullptr;
845 napi_value res1 = nullptr;
846 napi_create_function(env, funcName.c_str(), funcName.size(),
847 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::DEBUG>, nullptr, &cb);
848 napi_call_function(env, nullptr, cb, argc, argv, &res1);
849 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
850
851 cb = nullptr;
852 napi_value res2 = nullptr;
853 napi_create_function(env, funcName.c_str(), funcName.size(),
854 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::ERROR>, nullptr, &cb);
855 napi_call_function(env, nullptr, cb, argc, argv, &res2);
856 ASSERT_CHECK_VALUE_TYPE(env, res2, napi_undefined);
857
858 cb = nullptr;
859 napi_value res3 = nullptr;
860 napi_create_function(env, funcName.c_str(), funcName.size(),
861 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::WARN>, nullptr, &cb);
862 napi_call_function(env, nullptr, cb, argc, argv, &res3);
863 ASSERT_CHECK_VALUE_TYPE(env, res3, napi_undefined);
864
865 cb = nullptr;
866 napi_value res4 = nullptr;
867 napi_create_function(env, funcName.c_str(), funcName.size(),
868 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::FATAL>, nullptr, &cb);
869 napi_call_function(env, nullptr, cb, argc, argv, &res4);
870 ASSERT_CHECK_VALUE_TYPE(env, res4, napi_undefined);
871 }
872
873 /* @tc.name: Console.TraceHybridStack
874 * @tc.desc: Test.
875 * @tc.type: FUNC
876 */
877 HWTEST_F(NativeEngineTest, ConsoleTest022, testing::ext::TestSize.Level0)
878 {
879 napi_env env = (napi_env)engine_;
880 size_t argc = 0;
881 napi_value res0 = nullptr;
882 std::string funcName = "TraceHybridStack";
883 napi_value argv[] = {nullptr};
884 napi_value cb = nullptr;
885 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TraceHybridStack, nullptr, &cb);
886 napi_call_function(env, nullptr, cb, argc, argv, &res0);
887 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
888
889 argc = 1;
890 std::string message = "abc"; // Random value
891 napi_value nativeMessage1 = nullptr;
892 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage1);
893 napi_value argv2[] = {nativeMessage1};
894
895 cb = nullptr;
896 napi_value res1 = nullptr;
897 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::TraceHybridStack, nullptr, &cb);
898 napi_call_function(env, nullptr, cb, argc, argv2, &res1);
899 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
900 }
901
902 /* @tc.name: GroupEnd
903 * @tc.desc: Test.
904 * @tc.type: FUNC
905 */
906 HWTEST_F(NativeEngineTest, ConsoleTest023, testing::ext::TestSize.Level0)
907 {
908 napi_env env = (napi_env)engine_;
909 size_t argc = 0;
910 napi_value res0 = nullptr;
911 std::string funcName = "GroupEnd";
912 napi_value argv[] = {nullptr};
913 napi_value cb = nullptr;
914 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::GroupEnd, nullptr, &cb);
915 napi_call_function(env, nullptr, cb, argc, argv, &res0);
916 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
917
918 // Test case 1: Normal case, groupIndent size is greater than GROUPINDETATIONWIDTH
919 constexpr size_t GROUPINDETATIONWIDTH = 2;
920 ConsoleTest::SetGroupIndent(std::string(10 + GROUPINDETATIONWIDTH, ' '));
921 napi_value argv1[] = {nullptr};
922 napi_value res1 = nullptr;
923 napi_create_function(env, funcName.c_str(), funcName.size(), ConsoleTest::GroupEnd, nullptr, &cb);
924 napi_call_function(env, nullptr, cb, argc, argv1, &res1);
925 ASSERT_CHECK_VALUE_TYPE(env, res1, napi_undefined);
926 ASSERT_EQ(ConsoleTest::GetGroupIndent().size(), 10); // Check if groupIndent is correctly reduced
927 }
928
929 /* @tc.name: ConsoleLog
930 * @tc.desc: Test.
931 * @tc.type: FUNC
932 */
933 HWTEST_F(NativeEngineTest, ConsoleTest024, testing::ext::TestSize.Level0)
934 {
935 napi_env env = (napi_env)engine_;
936 size_t argc = 3;
937 std::string message = "";
938 napi_value nativeMessage0 = nullptr;
939 napi_create_string_utf8(env, message.c_str(), message.length(), &nativeMessage0);
940 napi_value nativeMessage1 = nullptr;
941 std::string message2 = "test console";
942 napi_value nativeMessage3 = nullptr;
943 napi_create_string_utf8(env, message2.c_str(), message2.length(), &nativeMessage3);
944 napi_value argv[] = {nativeMessage0, nativeMessage1, nativeMessage3};
945
946 std::string funcName = "ConsoleLog";
947 napi_value cb = nullptr;
948 napi_value res0 = nullptr;
949 napi_create_function(env, funcName.c_str(), funcName.size(),
950 ConsoleTest::ConsoleLog<OHOS::JsSysModule::LogLevel::INFO>, nullptr, &cb);
951 napi_call_function(env, nullptr, cb, argc, argv, &res0);
952 ASSERT_CHECK_VALUE_TYPE(env, res0, napi_undefined);
953 }
954
955 /* @tc.name: ParseLogContent
956 * @tc.desc: Test.
957 * @tc.type: FUNC
958 */
959 HWTEST_F(NativeEngineTest, ConsoleTest025, testing::ext::TestSize.Level0)
960 {
961 std::string res;
962 std::vector<std::string> params;
963 res = ConsoleTest::ParseLogContent(params);
964 ASSERT_TRUE(res == "");
965 }
966
967 /* @tc.name: log
968 * @tc.desc: Test log can be write.
969 * @tc.type: FUNC
970 */
971 HWTEST_F(NativeEngineTest, ConsoleTest026, testing::ext::TestSize.Level0)
972 {
973 NativeEngineProxy env;
974 napi_value func = nullptr;
975 napi_status status = napi_create_function(env, "log", NAPI_AUTO_LENGTH,
976 ConsoleTest::ConsoleLog<LogLevel::INFO>, nullptr, &func);
977 ASSERT_TRUE(status == napi_ok);
978 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
979 napi_value globalConsole = nullptr;
980 napi_get_named_property(env, globalObj, "console", &globalConsole);
981 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "log", func) == napi_ok);
982 }
983
984 /* @tc.name: debug
985 * @tc.desc: Test debug can be write.
986 * @tc.type: FUNC
987 */
988 HWTEST_F(NativeEngineTest, ConsoleTest027, testing::ext::TestSize.Level0)
989 {
990 NativeEngineProxy env;
991 napi_value func = nullptr;
992 napi_status status = napi_create_function(env, "debug", NAPI_AUTO_LENGTH,
993 ConsoleTest::ConsoleLog<LogLevel::DEBUG>, nullptr, &func);
994 ASSERT_TRUE(status == napi_ok);
995 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
996 napi_value globalConsole = nullptr;
997 napi_get_named_property(env, globalObj, "console", &globalConsole);
998 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "debug", func) == napi_ok);
999 }
1000
1001 /* @tc.name: info
1002 * @tc.desc: Test info can be write.
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(NativeEngineTest, ConsoleTest028, testing::ext::TestSize.Level0)
1006 {
1007 NativeEngineProxy env;
1008 napi_value func = nullptr;
1009 napi_status status = napi_create_function(env, "info", NAPI_AUTO_LENGTH,
1010 ConsoleTest::ConsoleLog<LogLevel::INFO>, nullptr, &func);
1011 ASSERT_TRUE(status == napi_ok);
1012 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1013 napi_value globalConsole = nullptr;
1014 napi_get_named_property(env, globalObj, "console", &globalConsole);
1015 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "info", func) == napi_ok);
1016 }
1017
1018 /* @tc.name: warn
1019 * @tc.desc: Test warn can be write.
1020 * @tc.type: FUNC
1021 */
1022 HWTEST_F(NativeEngineTest, ConsoleTest029, testing::ext::TestSize.Level0)
1023 {
1024 NativeEngineProxy env;
1025 napi_value func = nullptr;
1026 napi_status status = napi_create_function(env, "warn", NAPI_AUTO_LENGTH,
1027 ConsoleTest::ConsoleLog<LogLevel::WARN>, nullptr, &func);
1028 ASSERT_TRUE(status == napi_ok);
1029 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1030 napi_value globalConsole = nullptr;
1031 napi_get_named_property(env, globalObj, "console", &globalConsole);
1032 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "warn", func) == napi_ok);
1033 }
1034
1035 /* @tc.name: error
1036 * @tc.desc: Test error can be write.
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(NativeEngineTest, ConsoleTest030, testing::ext::TestSize.Level0)
1040 {
1041 NativeEngineProxy env;
1042 napi_value func = nullptr;
1043 napi_status status = napi_create_function(env, "error", NAPI_AUTO_LENGTH,
1044 ConsoleTest::ConsoleLog<LogLevel::ERROR>, nullptr, &func);
1045 ASSERT_TRUE(status == napi_ok);
1046 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1047 napi_value globalConsole = nullptr;
1048 napi_get_named_property(env, globalObj, "console", &globalConsole);
1049 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "error", func) == napi_ok);
1050 }
1051
1052 /* @tc.name: fatal
1053 * @tc.desc: Test fatal can be write.
1054 * @tc.type: FUNC
1055 */
1056 HWTEST_F(NativeEngineTest, ConsoleTest031, testing::ext::TestSize.Level0)
1057 {
1058 NativeEngineProxy env;
1059 napi_value func = nullptr;
1060 napi_status status = napi_create_function(env, "fatal", NAPI_AUTO_LENGTH,
1061 ConsoleTest::ConsoleLog<LogLevel::FATAL>, nullptr, &func);
1062 ASSERT_TRUE(status == napi_ok);
1063 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1064 napi_value globalConsole = nullptr;
1065 napi_get_named_property(env, globalObj, "console", &globalConsole);
1066 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "fatal", func) == napi_ok);
1067 }
1068
1069 /* @tc.name: group
1070 * @tc.desc: Test group can be write.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(NativeEngineTest, ConsoleTest032, testing::ext::TestSize.Level0)
1074 {
1075 NativeEngineProxy env;
1076 napi_value func = nullptr;
1077 napi_status status = napi_create_function(env, "group", NAPI_AUTO_LENGTH,
1078 ConsoleTest::Group, nullptr, &func);
1079 ASSERT_TRUE(status == napi_ok);
1080 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1081 napi_value globalConsole = nullptr;
1082 napi_get_named_property(env, globalObj, "console", &globalConsole);
1083 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "group", func) == napi_ok);
1084 }
1085
1086 /* @tc.name: groupCollapsed
1087 * @tc.desc: Test groupCollapsed can be write.
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(NativeEngineTest, ConsoleTest033, testing::ext::TestSize.Level0)
1091 {
1092 NativeEngineProxy env;
1093 napi_value func = nullptr;
1094 napi_status status = napi_create_function(env, "groupCollapsed", NAPI_AUTO_LENGTH,
1095 ConsoleTest::Group, nullptr, &func);
1096 ASSERT_TRUE(status == napi_ok);
1097 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1098 napi_value globalConsole = nullptr;
1099 napi_get_named_property(env, globalObj, "console", &globalConsole);
1100 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "groupCollapsed", func) == napi_ok);
1101 }
1102
1103 /* @tc.name: groupEnd
1104 * @tc.desc: Test groupEnd can be write.
1105 * @tc.type: FUNC
1106 */
1107 HWTEST_F(NativeEngineTest, ConsoleTest034, testing::ext::TestSize.Level0)
1108 {
1109 NativeEngineProxy env;
1110 napi_value func = nullptr;
1111 napi_status status = napi_create_function(env, "groupEnd", NAPI_AUTO_LENGTH,
1112 ConsoleTest::GroupEnd, nullptr, &func);
1113 ASSERT_TRUE(status == napi_ok);
1114 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1115 napi_value globalConsole = nullptr;
1116 napi_get_named_property(env, globalObj, "console", &globalConsole);
1117 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "groupEnd", func) == napi_ok);
1118 }
1119
1120 /* @tc.name: table
1121 * @tc.desc: Test table can be write.
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(NativeEngineTest, ConsoleTest035, testing::ext::TestSize.Level0)
1125 {
1126 NativeEngineProxy env;
1127 napi_value func = nullptr;
1128 napi_status status = napi_create_function(env, "table", NAPI_AUTO_LENGTH,
1129 ConsoleTest::Table, nullptr, &func);
1130 ASSERT_TRUE(status == napi_ok);
1131 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1132 napi_value globalConsole = nullptr;
1133 napi_get_named_property(env, globalObj, "console", &globalConsole);
1134 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "table", func) == napi_ok);
1135 }
1136
1137 /* @tc.name: time
1138 * @tc.desc: Test time can be write.
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(NativeEngineTest, ConsoleTest036, testing::ext::TestSize.Level0)
1142 {
1143 NativeEngineProxy env;
1144 napi_value func = nullptr;
1145 napi_status status = napi_create_function(env, "time", NAPI_AUTO_LENGTH,
1146 ConsoleTest::Time, nullptr, &func);
1147 ASSERT_TRUE(status == napi_ok);
1148 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1149 napi_value globalConsole = nullptr;
1150 napi_get_named_property(env, globalObj, "console", &globalConsole);
1151 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "time", func) == napi_ok);
1152 }
1153
1154 /* @tc.name: timeLog
1155 * @tc.desc: Test timeLog can be write.
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(NativeEngineTest, ConsoleTest037, testing::ext::TestSize.Level0)
1159 {
1160 NativeEngineProxy env;
1161 napi_value func = nullptr;
1162 napi_status status = napi_create_function(env, "timeLog", NAPI_AUTO_LENGTH,
1163 ConsoleTest::TimeLog, nullptr, &func);
1164 ASSERT_TRUE(status == napi_ok);
1165 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1166 napi_value globalConsole = nullptr;
1167 napi_get_named_property(env, globalObj, "console", &globalConsole);
1168 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "timeLog", func) == napi_ok);
1169 }
1170
1171 /* @tc.name: timeEnd
1172 * @tc.desc: Test timeEnd can be write.
1173 * @tc.type: FUNC
1174 */
1175 HWTEST_F(NativeEngineTest, ConsoleTest038, testing::ext::TestSize.Level0)
1176 {
1177 NativeEngineProxy env;
1178 napi_value func = nullptr;
1179 napi_status status = napi_create_function(env, "timeEnd", NAPI_AUTO_LENGTH,
1180 ConsoleTest::TimeEnd, nullptr, &func);
1181 ASSERT_TRUE(status == napi_ok);
1182 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1183 napi_value globalConsole = nullptr;
1184 napi_get_named_property(env, globalObj, "console", &globalConsole);
1185 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "timeEnd", func) == napi_ok);
1186 }
1187
1188 /* @tc.name: trace
1189 * @tc.desc: Test trace can be write.
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(NativeEngineTest, ConsoleTest039, testing::ext::TestSize.Level0)
1193 {
1194 NativeEngineProxy env;
1195 napi_value func = nullptr;
1196 napi_status status = napi_create_function(env, "trace", NAPI_AUTO_LENGTH,
1197 ConsoleTest::Trace, nullptr, &func);
1198 ASSERT_TRUE(status == napi_ok);
1199 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1200 napi_value globalConsole = nullptr;
1201 napi_get_named_property(env, globalObj, "console", &globalConsole);
1202 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "trace", func) == napi_ok);
1203 }
1204
1205 /* @tc.name: traceHybridStack
1206 * @tc.desc: Test traceHybridStack can be write.
1207 * @tc.type: FUNC
1208 */
1209 HWTEST_F(NativeEngineTest, ConsoleTest040, testing::ext::TestSize.Level0)
1210 {
1211 NativeEngineProxy env;
1212 napi_value func = nullptr;
1213 napi_status status = napi_create_function(env, "traceHybridStack", NAPI_AUTO_LENGTH,
1214 ConsoleTest::TraceHybridStack, nullptr, &func);
1215 ASSERT_TRUE(status == napi_ok);
1216 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1217 napi_value globalConsole = nullptr;
1218 napi_get_named_property(env, globalObj, "console", &globalConsole);
1219 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "traceHybridStack", func) == napi_ok);
1220 }
1221
1222 /* @tc.name: assert
1223 * @tc.desc: Test assert can be write.
1224 * @tc.type: FUNC
1225 */
1226 HWTEST_F(NativeEngineTest, ConsoleTest041, testing::ext::TestSize.Level0)
1227 {
1228 NativeEngineProxy env;
1229 napi_value func = nullptr;
1230 napi_status status = napi_create_function(env, "assert", NAPI_AUTO_LENGTH,
1231 ConsoleTest::Assert, nullptr, &func);
1232 ASSERT_TRUE(status == napi_ok);
1233 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1234 napi_value globalConsole = nullptr;
1235 napi_get_named_property(env, globalObj, "console", &globalConsole);
1236 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "assert", func) == napi_ok);
1237 }
1238
1239 /* @tc.name: count
1240 * @tc.desc: Test count can be write.
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(NativeEngineTest, ConsoleTest042, testing::ext::TestSize.Level0)
1244 {
1245 NativeEngineProxy env;
1246 napi_value func = nullptr;
1247 napi_status status = napi_create_function(env, "count", NAPI_AUTO_LENGTH,
1248 ConsoleTest::Count, nullptr, &func);
1249 ASSERT_TRUE(status == napi_ok);
1250 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1251 napi_value globalConsole = nullptr;
1252 napi_get_named_property(env, globalObj, "console", &globalConsole);
1253 ASSERT_TRUE(napi_set_named_property(env, globalConsole, "count", func) == napi_ok);
1254 }
1255
1256 /* @tc.name: countReset
1257 * @tc.desc: Test countReset can be write.
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(NativeEngineTest, ConsoleTest043, testing::ext::TestSize.Level0)
1261 {
1262 NativeEngineProxy env;
1263 napi_value func = nullptr;
1264 napi_status status = napi_create_function(env, "countReset", NAPI_AUTO_LENGTH,
1265 ConsoleTest::CountReset, nullptr, &func);
1266 ASSERT_TRUE(status == napi_ok);
1267 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1268 ASSERT_TRUE(napi_set_named_property(env, globalObj, "countReset", func) == napi_ok);
1269 }
1270
1271 /* @tc.name: dir
1272 * @tc.desc: Test dir can be write.
1273 * @tc.type: FUNC
1274 */
1275 HWTEST_F(NativeEngineTest, ConsoleTest044, testing::ext::TestSize.Level0)
1276 {
1277 NativeEngineProxy env;
1278 napi_value func = nullptr;
1279 napi_status status = napi_create_function(env, "dir", NAPI_AUTO_LENGTH,
1280 ConsoleTest::Dir, nullptr, &func);
1281 ASSERT_TRUE(status == napi_ok);
1282 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1283 ASSERT_TRUE(napi_set_named_property(env, globalObj, "dir", func) == napi_ok);
1284 }
1285
1286 /* @tc.name: dirxml
1287 * @tc.desc: Test dirxml can be write.
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(NativeEngineTest, ConsoleTest045, testing::ext::TestSize.Level0)
1291 {
1292 NativeEngineProxy env;
1293 napi_value func = nullptr;
1294 napi_status status = napi_create_function(env, "dirxml", NAPI_AUTO_LENGTH,
1295 ConsoleTest::ConsoleLog<LogLevel::INFO>, nullptr, &func);
1296 ASSERT_TRUE(status == napi_ok);
1297 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1298 ASSERT_TRUE(napi_set_named_property(env, globalObj, "dirxml", func) == napi_ok);
1299 }
1300
1301 /* @tc.name: log
1302 * @tc.desc: Test log debug info warn property not change.
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(NativeEngineTest, ConsoleTest046, testing::ext::TestSize.Level0)
1306 {
1307 NativeEngineProxy env;
1308 napi_value func1 = nullptr;
1309 napi_status status = napi_create_function(env, "log", NAPI_AUTO_LENGTH,
1310 ConsoleTest::ConsoleLog<LogLevel::INFO>, nullptr, &func1);
1311 napi_value func2 = nullptr;
1312 status = napi_create_function(env, "debug", NAPI_AUTO_LENGTH,
1313 ConsoleTest::ConsoleLog<LogLevel::DEBUG>, nullptr, &func2);
1314 napi_value func3 = nullptr;
1315 status = napi_create_function(env, "info", NAPI_AUTO_LENGTH,
1316 ConsoleTest::ConsoleLog<LogLevel::INFO>, nullptr, &func3);
1317 napi_value func4 = nullptr;
1318 status = napi_create_function(env, "warn", NAPI_AUTO_LENGTH,
1319 ConsoleTest::ConsoleLog<LogLevel::WARN>, nullptr, &func4);
1320 ASSERT_TRUE(status == napi_ok);
1321 napi_property_descriptor properties[] = {
1322 // napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable
1323 {"log", nullptr, nullptr, nullptr, nullptr, func1, napi_default_jsproperty, nullptr},
1324 {"debug", nullptr, nullptr, nullptr, nullptr, func2, napi_default_jsproperty, nullptr},
1325 {"info", nullptr, nullptr, nullptr, nullptr, func3, napi_default_jsproperty, nullptr},
1326 {"warn", nullptr, nullptr, nullptr, nullptr, func4, napi_default_jsproperty, nullptr}
1327 };
1328 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1329 napi_value console = nullptr;
1330 status = napi_get_named_property(env, globalObj, "console", &console);
1331 ASSERT_TRUE(status == napi_ok);
1332 status = napi_define_properties(env, console, sizeof(properties) / sizeof(properties[0]), properties);
1333 ASSERT_TRUE(status == napi_ok);
1334 napi_value logCB = GetGlobalProperty(env, "log");
1335 napi_value debugCB = GetGlobalProperty(env, "debug");
1336 napi_value infoCB = GetGlobalProperty(env, "info");
1337 napi_value warnCB = GetGlobalProperty(env, "warn");
1338 bool isEqual = false;
1339 napi_strict_equals(env, logCB, func1, &isEqual);
1340 ASSERT_TRUE(isEqual);
1341 napi_strict_equals(env, debugCB, func2, &isEqual);
1342 ASSERT_TRUE(isEqual);
1343 napi_strict_equals(env, infoCB, func3, &isEqual);
1344 ASSERT_TRUE(isEqual);
1345 napi_strict_equals(env, warnCB, func4, &isEqual);
1346 ASSERT_TRUE(isEqual);
1347 }
1348
1349 /* @tc.name: error
1350 * @tc.desc: Test error fatal group property not change.
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(NativeEngineTest, ConsoleTest047, testing::ext::TestSize.Level0)
1354 {
1355 NativeEngineProxy env;
1356 napi_value func1 = nullptr;
1357 napi_status status = napi_create_function(env, "error", NAPI_AUTO_LENGTH,
1358 ConsoleTest::ConsoleLog<LogLevel::ERROR>, nullptr, &func1);
1359 ASSERT_TRUE(status == napi_ok);
1360 napi_value func2 = nullptr;
1361 napi_create_function(env, "fatal", NAPI_AUTO_LENGTH, ConsoleTest::ConsoleLog<LogLevel::FATAL>, nullptr, &func2);
1362 napi_value func3 = nullptr;
1363 napi_create_function(env, "group", NAPI_AUTO_LENGTH, ConsoleTest::Group, nullptr, &func3);
1364 napi_value func4 = nullptr;
1365 napi_create_function(env, "groupCollapsed", NAPI_AUTO_LENGTH, ConsoleTest::Group, nullptr, &func4);
1366 napi_value func5 = nullptr;
1367 napi_create_function(env, "groupEnd", NAPI_AUTO_LENGTH, ConsoleTest::GroupEnd, nullptr, &func5);
1368 napi_property_descriptor properties[] = {
1369 // napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable
1370 {"error", nullptr, nullptr, nullptr, nullptr, func1, napi_default_jsproperty, nullptr},
1371 {"fatal", nullptr, nullptr, nullptr, nullptr, func2, napi_default_jsproperty, nullptr},
1372 {"group", nullptr, nullptr, nullptr, nullptr, func3, napi_default_jsproperty, nullptr},
1373 {"groupCollapsed", nullptr, nullptr, nullptr, nullptr, func4, napi_default_jsproperty, nullptr},
1374 {"groupEnd", nullptr, nullptr, nullptr, nullptr, func5, napi_default_jsproperty, nullptr}
1375 };
1376 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1377 napi_value console = nullptr;
1378 napi_get_named_property(env, globalObj, "console", &console);
1379 status = napi_define_properties(env, console, sizeof(properties) / sizeof(properties[0]), properties);
1380 ASSERT_TRUE(status == napi_ok);
1381 napi_value errorCB = GetGlobalProperty(env, "error");
1382 napi_value fatalCB = GetGlobalProperty(env, "fatal");
1383 napi_value groupCB = GetGlobalProperty(env, "group");
1384 napi_value groupCollapsedCB = GetGlobalProperty(env, "groupCollapsed");
1385 napi_value groupEndCB = GetGlobalProperty(env, "groupEnd");
1386 bool isEqual = false;
1387 napi_strict_equals(env, errorCB, func1, &isEqual);
1388 ASSERT_TRUE(isEqual);
1389 napi_strict_equals(env, fatalCB, func2, &isEqual);
1390 ASSERT_TRUE(isEqual);
1391 napi_strict_equals(env, groupCB, func3, &isEqual);
1392 ASSERT_TRUE(isEqual);
1393 napi_strict_equals(env, groupCollapsedCB, func4, &isEqual);
1394 ASSERT_TRUE(isEqual);
1395 napi_strict_equals(env, groupEndCB, func5, &isEqual);
1396 ASSERT_TRUE(isEqual);
1397 }
1398
1399 /* @tc.name: table
1400 * @tc.desc: Test table time trace property not change.
1401 * @tc.type: FUNC
1402 */
1403 HWTEST_F(NativeEngineTest, ConsoleTest048, testing::ext::TestSize.Level0)
1404 {
1405 NativeEngineProxy env;
1406 napi_value func1 = nullptr;
1407 napi_create_function(env, "table", NAPI_AUTO_LENGTH, ConsoleTest::Table, nullptr, &func1);
1408 napi_value func2 = nullptr;
1409 napi_create_function(env, "time", NAPI_AUTO_LENGTH, ConsoleTest::Time, nullptr, &func2);
1410 napi_value func3 = nullptr;
1411 napi_create_function(env, "timeLog", NAPI_AUTO_LENGTH, ConsoleTest::TimeLog, nullptr, &func3);
1412 napi_value func4 = nullptr;
1413 napi_create_function(env, "timeEnd", NAPI_AUTO_LENGTH, ConsoleTest::TimeEnd, nullptr, &func4);
1414 napi_value func5 = nullptr;
1415 napi_create_function(env, "trace", NAPI_AUTO_LENGTH, ConsoleTest::Trace, nullptr, &func5);
1416 napi_value func6 = nullptr;
1417 napi_create_function(env, "traceHybridStack", NAPI_AUTO_LENGTH, ConsoleTest::TraceHybridStack, nullptr, &func6);
1418 napi_property_descriptor properties[] = {
1419 // napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable
1420 {"table", nullptr, nullptr, nullptr, nullptr, func1, napi_default_jsproperty, nullptr},
1421 {"time", nullptr, nullptr, nullptr, nullptr, func2, napi_default_jsproperty, nullptr},
1422 {"timeLog", nullptr, nullptr, nullptr, nullptr, func3, napi_default_jsproperty, nullptr},
1423 {"timeEnd", nullptr, nullptr, nullptr, nullptr, func4, napi_default_jsproperty, nullptr},
1424 {"trace", nullptr, nullptr, nullptr, nullptr, func5, napi_default_jsproperty, nullptr},
1425 {"traceHybridStack", nullptr, nullptr, nullptr, nullptr, func6, napi_default_jsproperty, nullptr}
1426 };
1427 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1428 napi_value console = nullptr;
1429 napi_get_named_property(env, globalObj, "console", &console);
1430 napi_define_properties(env, console, sizeof(properties) / sizeof(properties[0]), properties);
1431 napi_value tableCB = GetGlobalProperty(env, "table");
1432 napi_value timeCB = GetGlobalProperty(env, "time");
1433 napi_value timeLogCB = GetGlobalProperty(env, "timeLog");
1434 napi_value timeEndCB = GetGlobalProperty(env, "timeEnd");
1435 napi_value traceCB = GetGlobalProperty(env, "trace");
1436 napi_value traceHybridStackCB = GetGlobalProperty(env, "traceHybridStack");
1437 bool isEqual = false;
1438 napi_strict_equals(env, tableCB, func1, &isEqual);
1439 ASSERT_TRUE(isEqual);
1440 napi_strict_equals(env, timeCB, func2, &isEqual);
1441 ASSERT_TRUE(isEqual);
1442 napi_strict_equals(env, timeLogCB, func3, &isEqual);
1443 ASSERT_TRUE(isEqual);
1444 napi_strict_equals(env, timeEndCB, func4, &isEqual);
1445 ASSERT_TRUE(isEqual);
1446 napi_strict_equals(env, traceCB, func5, &isEqual);
1447 ASSERT_TRUE(isEqual);
1448 napi_strict_equals(env, traceHybridStackCB, func6, &isEqual);
1449 ASSERT_TRUE(isEqual);
1450 }
1451
1452 /* @tc.name: assert
1453 * @tc.desc: Test assert count dir property not change.
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(NativeEngineTest, ConsoleTest049, testing::ext::TestSize.Level0)
1457 {
1458 NativeEngineProxy env;
1459 napi_value func1 = nullptr;
1460 napi_create_function(env, "assert", NAPI_AUTO_LENGTH, ConsoleTest::Assert, nullptr, &func1);
1461 napi_value func2 = nullptr;
1462 napi_create_function(env, "count", NAPI_AUTO_LENGTH, ConsoleTest::Count, nullptr, &func2);
1463 napi_value func3 = nullptr;
1464 napi_create_function(env, "countReset", NAPI_AUTO_LENGTH, ConsoleTest::CountReset, nullptr, &func3);
1465 napi_value func4 = nullptr;
1466 napi_create_function(env, "dir", NAPI_AUTO_LENGTH, ConsoleTest::Dir, nullptr, &func4);
1467 napi_value func5 = nullptr;
1468 napi_create_function(env, "dirxml", NAPI_AUTO_LENGTH, ConsoleTest::ConsoleLog<LogLevel::INFO>, nullptr, &func5);
1469 napi_property_descriptor properties[] = {
1470 // napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable
1471 {"assert", nullptr, nullptr, nullptr, nullptr, func1, napi_default_jsproperty, nullptr},
1472 {"count", nullptr, nullptr, nullptr, nullptr, func2, napi_default_jsproperty, nullptr},
1473 {"countReset", nullptr, nullptr, nullptr, nullptr, func3, napi_default_jsproperty, nullptr},
1474 {"dir", nullptr, nullptr, nullptr, nullptr, func4, napi_default_jsproperty, nullptr},
1475 {"dirxml", nullptr, nullptr, nullptr, nullptr, func5, napi_default_jsproperty, nullptr}
1476 };
1477 napi_value globalObj = Helper::NapiHelper::GetGlobalObject(env);
1478 napi_value console = nullptr;
1479 napi_get_named_property(env, globalObj, "console", &console);
1480 napi_status status = napi_define_properties(env, console, sizeof(properties) / sizeof(properties[0]), properties);
1481 ASSERT_TRUE(status == napi_ok);
1482 napi_value assertCB = GetGlobalProperty(env, "assert");
1483 napi_value countCB = GetGlobalProperty(env, "count");
1484 napi_value countResetCB = GetGlobalProperty(env, "countReset");
1485 napi_value dirCB = GetGlobalProperty(env, "dir");
1486 napi_value dirxmlCB = GetGlobalProperty(env, "dirxml");
1487 bool isEqual = false;
1488 napi_strict_equals(env, assertCB, func1, &isEqual);
1489 ASSERT_TRUE(isEqual);
1490 napi_strict_equals(env, countCB, func2, &isEqual);
1491 ASSERT_TRUE(isEqual);
1492 napi_strict_equals(env, countResetCB, func3, &isEqual);
1493 ASSERT_TRUE(isEqual);
1494 napi_strict_equals(env, dirCB, func4, &isEqual);
1495 ASSERT_TRUE(isEqual);
1496 napi_strict_equals(env, dirxmlCB, func5, &isEqual);
1497 ASSERT_TRUE(isEqual);
1498 }