1# Copyright (c) 2021-2024 Huawei Device Co., Ltd. 2# Licensed under the Apache License, Version 2.0 (the "License"); 3# you may not use this file except in compliance with the License. 4# You may obtain a copy of the License at 5# 6# http://www.apache.org/licenses/LICENSE-2.0 7# 8# Unless required by applicable law or agreed to in writing, software 9# distributed under the License is distributed on an "AS IS" BASIS, 10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11# See the License for the specific language governing permissions and 12# limitations under the License. 13 14import("//build/test.gni") 15import("../../powermgr.gni") 16import("../powermgr_test.gni") 17 18module_output_path = "power_manager/power_manager" 19 20############################################################################### 21config("module_private_config") { 22 visibility = [ ":*" ] 23 24 include_dirs = [ 25 "include", 26 "include/interface_test", 27 "include/scenario_test/running_lock", 28 "include/scenario_test/wakeup_suspend", 29 "mock", 30 "include/utils", 31 "${powermgr_service_zidl}/include", 32 "${powermgr_service_zidl}/src/shutdown", 33 "${powermgr_service_path}/native/include", 34 "${powermgr_service_path}/native/src/", 35 "${powermgr_service_path}/native/src/actions/", 36 "${powermgr_service_path}/native/src/actions/default", 37 "${powermgr_service_path}/native/src/hibernate", 38 "${powermgr_service_path}/native/src/proximity_sensor_controller", 39 "${powermgr_service_path}/native/src/runninglock", 40 "${powermgr_service_path}/native/src/shutdown", 41 "${powermgr_service_path}/native/src/suspend", 42 "${powermgr_service_path}/native/src/wakeup", 43 "${powermgr_service_path}/native/src/screenoffpre", 44 "${powermgr_test_path}/mock/action", 45 ] 46 47 if (power_manager_feature_wakeup_action) { 48 include_dirs += [ "${powermgr_service_path}/native/src/wakeup_action" ] 49 } 50} 51 52config("module_mock_private_config") { 53 include_dirs = [ 54 "include/mock", 55 "mock", 56 "${powermgr_service_zidl}/include", 57 "${powermgr_service_path}/test/mock/action", 58 ] 59} 60 61deps_ex = [ 62 "ability_base:base", 63 "ability_base:want", 64 "ability_runtime:ability_manager", 65 "cJSON:cjson", 66 "c_utils:utils", 67 "common_event_service:cesfwk_innerkits", 68 "config_policy:configpolicy_util", 69 "ffrt:libffrt", 70 "googletest:gmock_main", 71 "googletest:gtest_main", 72 "hilog:libhilog", 73 "ipc:ipc_core", 74 "libxml2:libxml2", 75 "power_manager:power_ffrt", 76 "safwk:system_ability_fwk", 77 "samgr:samgr_proxy", 78 "window_manager:libdm_lite", 79 "window_manager:libwm_lite", 80] 81 82if (has_multimodalinput_input_part) { 83 deps_ex += [ "input:libmmi-client" ] 84} 85if (has_sensors_sensor_part) { 86 deps_ex += [ "sensor:sensor_interface_native" ] 87} 88if (has_hiviewdfx_hisysevent_part) { 89 deps_ex += [ "hisysevent:libhisysevent" ] 90} 91defs = [ "POWER_GTEST" ] 92 93##############################client_test########################################## 94 95ohos_unittest("test_power_key_option") { 96 module_out_path = module_output_path 97 98 sanitize = { 99 cfi = true 100 cfi_cross_dso = true 101 debug = false 102 blocklist = "../cfi_blocklist.txt" 103 } 104 105 sources = [ "src/interface_test/power_key_option_test.cpp" ] 106 107 configs = [ 108 "${powermgr_utils_path}:utils_config", 109 ":module_private_config", 110 ":module_mock_private_config", 111 "${powermgr_utils_path}:coverage_flags", 112 ] 113 114 defines += [ "POWERMGR_GTEST" ] 115 116 deps = [ "${powermgr_service_path}:powermgrservice" ] 117 118 external_deps = deps_ex 119} 120 121ohos_unittest("test_power_mgr_client") { 122 module_out_path = module_output_path 123 124 sources = [ 125 "src/interface_test/power_mgr_client_test.cpp", 126 "mock/mock_power_remote_object.cpp", 127 ] 128 129 sanitize = { 130 cfi = true 131 cfi_cross_dso = true 132 debug = false 133 blocklist = "../cfi_blocklist.txt" 134 } 135 136 configs = [ 137 "${powermgr_utils_path}:utils_config", 138 ":module_private_config", 139 "${powermgr_utils_path}:coverage_flags", 140 ] 141 142 deps = [ 143 "${powermgr_inner_api}:powermgr_client", 144 "${powermgr_inner_api}:powermgr_stub", 145 "${powermgr_service_path}:powermgrservice", 146 "${powermgr_service_path}/native/src/actions:powermgr_actions", 147 ] 148 149 if (has_display_manager_part) { 150 deps_ex += [ "display_manager:displaymgr" ] 151 } 152 external_deps = deps_ex 153 154 if (power_manager_feature_force_sleep_broadcast) { 155 defines += [ "POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST" ] 156 } 157} 158 159##############################unittest########################################## 160ohos_unittest("test_register_callback_mode") { 161 module_out_path = module_output_path 162 163 sources = [ "src/power_register_callback_mode_test.cpp" ] 164 165 sanitize = { 166 cfi = true 167 cfi_cross_dso = true 168 debug = false 169 blocklist = "../cfi_blocklist.txt" 170 } 171 172 configs = [ 173 "${powermgr_utils_path}:utils_config", 174 ":module_private_config", 175 "${powermgr_utils_path}:coverage_flags", 176 ] 177 178 deps = [ 179 "${powermgr_inner_api}:powermgr_client", 180 "${powermgr_inner_api}:powermgr_stub", 181 "${powermgr_service_path}:powermgrservice", 182 "${powermgr_service_path}/native/src/actions:powermgr_actions", 183 ] 184 185 external_deps = deps_ex 186} 187 188ohos_unittest("test_power_get_mode") { 189 module_out_path = module_output_path 190 191 sources = [ "src/power_get_mode_test.cpp" ] 192 193 sanitize = { 194 cfi = true 195 cfi_cross_dso = true 196 debug = false 197 blocklist = "../cfi_blocklist.txt" 198 } 199 200 configs = [ 201 "${powermgr_utils_path}:utils_config", 202 ":module_private_config", 203 "${powermgr_utils_path}:coverage_flags", 204 ] 205 206 deps = [ 207 "${powermgr_inner_api}:powermgr_client", 208 "${powermgr_inner_api}:powermgr_stub", 209 "${powermgr_service_path}:powermgrservice", 210 "${powermgr_service_path}/native/src/actions:powermgr_actions", 211 ] 212 213 external_deps = deps_ex 214} 215 216ohos_unittest("test_power_set_mode") { 217 module_out_path = module_output_path 218 219 sources = [ "src/power_set_mode_test.cpp" ] 220 221 sanitize = { 222 cfi = true 223 cfi_cross_dso = true 224 debug = false 225 blocklist = "../cfi_blocklist.txt" 226 } 227 228 configs = [ 229 "${powermgr_utils_path}:utils_config", 230 ":module_private_config", 231 "${powermgr_utils_path}:coverage_flags", 232 ] 233 234 deps = [ 235 "${powermgr_inner_api}:powermgr_client", 236 "${powermgr_inner_api}:powermgr_stub", 237 "${powermgr_service_path}:powermgrservice", 238 "${powermgr_service_path}/native/src/actions:powermgr_actions", 239 ] 240 241 external_deps = deps_ex 242} 243 244ohos_unittest("test_power_device_mode") { 245 module_out_path = module_output_path 246 247 sources = [ "src/power_device_mode_test.cpp" ] 248 249 configs = [ 250 "${powermgr_utils_path}:utils_config", 251 ":module_private_config", 252 "${powermgr_utils_path}:coverage_flags", 253 ] 254 255 deps = [ 256 "${powermgr_inner_api}:powermgr_client", 257 "${powermgr_service_path}:powermgrservice", 258 ] 259 260 external_deps = deps_ex 261} 262 263ohos_unittest("power_client_callback_test") { 264 module_out_path = module_output_path 265 266 sources = [ "src/power_client_callback_test.cpp" ] 267 268 configs = [ 269 "${powermgr_utils_path}:utils_config", 270 ":module_private_config", 271 "${powermgr_utils_path}:coverage_flags", 272 ] 273 274 deps = [ 275 "${powermgr_inner_api}:powermgr_client", 276 "${powermgr_service_path}:powermgrservice", 277 ] 278 279 external_deps = deps_ex 280} 281 282ohos_unittest("test_running_lock") { 283 module_out_path = module_output_path 284 285 sanitize = { 286 cfi = true 287 cfi_cross_dso = true 288 debug = false 289 blocklist = "../cfi_blocklist.txt" 290 } 291 292 sources = [ "src/interface_test/running_lock_test.cpp" ] 293 294 configs = [ 295 "${powermgr_utils_path}:utils_config", 296 ":module_private_config", 297 "${powermgr_utils_path}:coverage_flags", 298 ] 299 300 deps = [ 301 "${powermgr_inner_api}:powermgr_client", 302 "${powermgr_inner_api}:powermgr_proxy", 303 "${powermgr_service_path}:powermgrservice", 304 ] 305 306 external_deps = deps_ex 307} 308 309ohos_unittest("test_running_lock_scenario") { 310 module_out_path = module_output_path 311 312 sources = [ "src/scenario_test/running_lock/running_lock_scenario_test.cpp" ] 313 314 configs = [ 315 "${powermgr_utils_path}:utils_config", 316 ":module_private_config", 317 "${powermgr_utils_path}:coverage_flags", 318 ] 319 320 deps = [ 321 "${powermgr_inner_api}:powermgr_client", 322 "${powermgr_service_path}:powermgrservice", 323 ] 324 325 external_deps = deps_ex 326} 327 328ohos_unittest("test_power_mgr_service") { 329 module_out_path = module_output_path 330 331 sanitize = { 332 cfi = true 333 cfi_cross_dso = true 334 debug = false 335 blocklist = "../cfi_blocklist.txt" 336 } 337 338 sources = [ "src/interface_test/power_mgr_service_test.cpp" ] 339 340 if (power_manager_feature_tv_dreaming) { 341 defines += [ "POWER_MANAGER_TV_DREAMING" ] 342 } 343 344 if (power_manager_feature_force_sleep_broadcast) { 345 defines += [ "POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST" ] 346 } 347 348 configs = [ 349 "${powermgr_utils_path}:utils_config", 350 ":module_private_config", 351 "${powermgr_utils_path}:coverage_flags", 352 ] 353 include_dirs = [ "${powermgr_service_path}/native/src/setting" ] 354 deps = [ 355 "${powermgr_inner_api}:powermgr_client", 356 "${powermgr_service_path}:powermgrservice", 357 "${powermgr_utils_path}:power_utils", 358 ] 359 360 external_deps = deps_ex + [ 361 "access_token:libaccesstoken_sdk", 362 "access_token:libnativetoken", 363 "access_token:libtoken_setproc", 364 "access_token:libtokenid_sdk", 365 "cJSON:cjson", 366 "data_share:datashare_common", 367 "data_share:datashare_consumer", 368 "selinux_adapter:librestorecon", 369 ] 370} 371 372ohos_unittest("test_power_mgr_service_ipc_adapter") { 373 module_out_path = module_output_path 374 375 sanitize = { 376 cfi = true 377 cfi_cross_dso = true 378 debug = false 379 blocklist = "../cfi_blocklist.txt" 380 } 381 382 sources = [ 383 "src/interface_test/power_mgr_service_ipc_adapter_test.cpp", 384 ] 385 386 if (power_manager_feature_tv_dreaming) { 387 defines += [ "POWER_MANAGER_TV_DREAMING" ] 388 } 389 390 if (power_manager_feature_force_sleep_broadcast) { 391 defines += [ "POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST" ] 392 } 393 394 configs = [ 395 "${powermgr_utils_path}:utils_config", 396 ":module_private_config", 397 "${powermgr_utils_path}:coverage_flags", 398 ] 399 include_dirs = [ "${powermgr_service_path}/native/include" ] 400 deps = [ "${powermgr_service_path}:powermgrservice" ] 401 402 external_deps = deps_ex + [ 403 "access_token:libaccesstoken_sdk", 404 "access_token:libnativetoken", 405 "access_token:libtoken_setproc", 406 "access_token:libtokenid_sdk", 407 "cJSON:cjson", 408 "data_share:datashare_common", 409 "data_share:datashare_consumer", 410 "selinux_adapter:librestorecon", 411 ] 412} 413 414ohos_unittest("test_power_mgr_service_death") { 415 module_out_path = module_output_path 416 417 sources = [ 418 "mock/mock_power_remote_object.cpp", 419 "src/power_mgr_service_death_test.cpp", 420 ] 421 422 configs = [ 423 "${powermgr_utils_path}:utils_config", 424 ":module_private_config", 425 "${powermgr_utils_path}:coverage_flags", 426 ] 427 428 defines += [ "POWERMGR_SERVICE_DEATH_UT" ] 429 430 deps = [ 431 "${powermgr_inner_api}:powermgr_client", 432 "${powermgr_service_path}:powermgrservice", 433 ] 434 435 external_deps = deps_ex 436} 437 438ohos_unittest("test_power_state_level_framework") { 439 module_out_path = module_output_path 440 441 resource_config_file = 442 "${powermgr_root_path}/test/unittest/resources/ohos_test.xml" 443 444 sources = [ "src/power_state_level_framework_test.cpp" ] 445 446 configs = [ 447 "${powermgr_utils_path}:utils_config", 448 ":module_private_config", 449 "${powermgr_utils_path}:coverage_flags", 450 ] 451 452 deps = [ 453 "${powermgr_inner_api}:powermgr_client", 454 "${powermgr_service_path}:powermgrservice", 455 ] 456 457 external_deps = deps_ex 458} 459 460ohos_unittest("test_power_state_machine") { 461 module_out_path = module_output_path 462 463 sources = [ "src/interface_test/power_state_machine_test.cpp" ] 464 465 sanitize = { 466 cfi = true 467 cfi_cross_dso = true 468 debug = false 469 blocklist = "../cfi_blocklist.txt" 470 } 471 472 configs = [ 473 "${powermgr_utils_path}:utils_config", 474 ":module_private_config", 475 "${powermgr_utils_path}:coverage_flags", 476 ] 477 478 deps = [ 479 "${powermgr_inner_api}:powermgr_client", 480 "${powermgr_inner_api}:powermgr_stub", 481 "${powermgr_service_path}:powermgrservice", 482 ] 483 484 external_deps = deps_ex 485} 486 487ohos_unittest("test_power_mgr_mock") { 488 module_out_path = module_output_path 489 490 sanitize = { 491 cfi = true 492 cfi_cross_dso = true 493 debug = false 494 blocklist = "../cfi_blocklist.txt" 495 } 496 497 sources = [ "src/power_mgr_mock_test.cpp" ] 498 499 configs = [ 500 "${powermgr_utils_path}:utils_config", 501 ":module_private_config", 502 "${powermgr_utils_path}:coverage_flags", 503 ] 504 505 deps = [ 506 "${powermgr_inner_api}:powermgr_client", 507 "${powermgr_inner_api}:powermgr_stub", 508 "${powermgr_service_path}:powermgrservice", 509 "${powermgr_service_path}/native/src/actions:powermgr_actions", 510 ] 511 512 external_deps = deps_ex 513} 514 515ohos_unittest("test_power_mgr_fail_check") { 516 module_out_path = module_output_path 517 518 sanitize = { 519 cfi = true 520 cfi_cross_dso = true 521 debug = false 522 blocklist = "../cfi_blocklist.txt" 523 } 524 525 sources = [ "src/power_mgr_fail_check_test.cpp" ] 526 527 configs = [ 528 "${powermgr_utils_path}:utils_config", 529 ":module_private_config", 530 "${powermgr_utils_path}:coverage_flags", 531 ] 532 533 deps = [ 534 "${powermgr_inner_api}:powermgr_client", 535 "${powermgr_inner_api}:powermgr_stub", 536 "${powermgr_service_path}:powermgrservice", 537 "${powermgr_service_path}/native/src/actions:powermgr_actions", 538 ] 539 540 external_deps = deps_ex 541} 542 543if (false) { 544 ohos_unittest("test_power_mgr_notify") { 545 module_out_path = module_output_path 546 547 sources = [ "src/power_mgr_notify_test.cpp" ] 548 549 configs = [ 550 "${powermgr_utils_path}:utils_config", 551 ":module_private_config", 552 "${powermgr_utils_path}:coverage_flags", 553 ] 554 555 deps = [ 556 "${powermgr_inner_api}:powermgr_client", 557 "${powermgr_service_path}:powermgrservice", 558 "${powermgr_service_path}/native/src/actions:powermgr_actions", 559 ] 560 561 external_deps = deps_ex 562 } 563} 564 565##############################coveragetest########################################## 566ohos_unittest("test_power_mgr_util") { 567 module_out_path = module_output_path 568 569 include_dirs = [ 570 "${powermgr_utils_path}/permission/include", 571 "${powermgr_utils_path}/param/include", 572 "${powermgr_utils_path}/setting/include", 573 "src/mock", 574 ] 575 576 sources = [ 577 "${powermgr_utils_path}/param/src/sysparam.cpp", 578 "${powermgr_utils_path}/permission/src/permission.cpp", 579 "${powermgr_utils_path}/setting/src/setting_observer.cpp", 580 "${powermgr_utils_path}/setting/src/setting_provider.cpp", 581 "src/interface_test/power_mgr_util_test.cpp", 582 "src/mock/mock_accesstoken_kit.cpp", 583 ] 584 585 configs = [ 586 "${powermgr_utils_path}:utils_config", 587 ":module_private_config", 588 "${powermgr_utils_path}:coverage_flags", 589 ] 590 591 deps = [ 592 "${powermgr_utils_path}/param:power_sysparam", 593 "${powermgr_utils_path}/setting:power_setting", 594 "${powermgr_utils_path}/vibrator:power_vibrator", 595 ] 596 597 external_deps = [ 598 "ability_base:zuri", 599 "ability_runtime:ability_manager", 600 "ability_runtime:dataobs_manager", 601 "access_token:libaccesstoken_sdk", 602 "access_token:libtokenid_sdk", 603 "data_share:datashare_common", 604 "data_share:datashare_consumer", 605 "init:libbeget_proxy", 606 "init:libbegetutil", 607 "os_account:os_account_innerkits", 608 ] 609 external_deps += deps_ex 610} 611 612ohos_unittest("test_power_mgr_power_appmgr") { 613 module_out_path = module_output_path 614 615 sources = [ "src/app_manager_utils_test.cpp" ] 616 617 configs = [ 618 "${powermgr_utils_path}:utils_config", 619 ":module_private_config", 620 "${powermgr_utils_path}:coverage_flags", 621 ] 622 623 deps = [ "${powermgr_utils_path}/appmgr:power_appmgr" ] 624 625 external_deps = [ 626 "ability_runtime:ability_manager", 627 "ability_runtime:app_manager", 628 "c_utils:utils", 629 "googletest:gmock_main", 630 "googletest:gtest_main", 631 "hilog:libhilog", 632 "ipc:ipc_core", 633 "samgr:samgr_proxy", 634 ] 635} 636 637ohos_unittest("test_power_mgr_power_lib_loader") { 638 module_out_path = module_output_path 639 640 sources = [ "src/interface_loader_test.cpp" ] 641 642 configs = [ 643 "${powermgr_utils_path}:utils_config", 644 ":module_private_config", 645 "${powermgr_utils_path}:coverage_flags", 646 ] 647 648 deps = [ "${powermgr_utils_path}/lib_loader:power_lib_loader" ] 649 650 external_deps = [ 651 "c_utils:utils", 652 "googletest:gmock_main", 653 "googletest:gtest_main", 654 "hilog:libhilog", 655 ] 656} 657 658ohos_unittest("test_power_mgr_power_intf_wrapper") { 659 module_out_path = module_output_path 660 661 sources = [ "src/power_ext_intf_wrapper_test.cpp" ] 662 663 configs = [ 664 "${powermgr_utils_path}:utils_config", 665 ":module_private_config", 666 "${powermgr_utils_path}:coverage_flags", 667 ] 668 669 deps = [ 670 "${powermgr_utils_path}/intf_wrapper:power_intf_wrapper", 671 "${powermgr_utils_path}/lib_loader:power_lib_loader", 672 ] 673 674 external_deps = [ 675 "c_utils:utils", 676 "googletest:gmock_main", 677 "googletest:gtest_main", 678 "hilog:libhilog", 679 ] 680} 681 682ohos_unittest("test_power_mock_object") { 683 module_out_path = module_output_path 684 685 sources = [ 686 "mock/mock_power_remote_object.cpp", 687 "src/mock/power_mock_object_test.cpp", 688 ] 689 690 sanitize = { 691 cfi = true 692 cfi_cross_dso = true 693 debug = false 694 blocklist = "../cfi_blocklist.txt" 695 } 696 697 configs = [ 698 "${powermgr_utils_path}:utils_config", 699 ":module_private_config", 700 ":module_mock_private_config", 701 "${powermgr_utils_path}:coverage_flags", 702 ] 703 704 deps = [ 705 "${powermgr_inner_api}:powermgr_client", 706 "${powermgr_inner_api}:powermgr_proxy", 707 "${powermgr_inner_api}:powermgr_stub", 708 "${powermgr_service_path}:powermgrservice", 709 ] 710 711 external_deps = deps_ex 712} 713 714ohos_unittest("test_mock_parcel") { 715 module_out_path = module_output_path 716 717 sources = [ 718 "mock/mock_message_parcel.cpp", 719 "mock/mock_parcel.cpp", 720 "src/mock/power_mock_parcel_test.cpp", 721 ] 722 723 sanitize = { 724 cfi = true 725 cfi_cross_dso = true 726 debug = false 727 blocklist = "../cfi_blocklist.txt" 728 } 729 730 configs = [ 731 "${powermgr_utils_path}:utils_config", 732 ":module_private_config", 733 ":module_mock_private_config", 734 "${powermgr_utils_path}:coverage_flags", 735 ] 736 737 deps = [ 738 "${powermgr_inner_api}:powermgr_client", 739 "${powermgr_inner_api}:powermgr_proxy", 740 "${powermgr_inner_api}:powermgr_stub", 741 "${powermgr_service_path}:powermgrservice", 742 "${powermgr_utils_path}/permission:power_permission", 743 ] 744 745 external_deps = deps_ex 746} 747 748ohos_unittest("test_mock_peer") { 749 module_out_path = module_output_path 750 751 sources = [ 752 "mock/mock_peer_holder.cpp", 753 "src/mock/power_mock_peer_test.cpp", 754 ] 755 756 sanitize = { 757 cfi = true 758 cfi_cross_dso = true 759 debug = false 760 blocklist = "../cfi_blocklist.txt" 761 } 762 763 configs = [ 764 "${powermgr_utils_path}:utils_config", 765 ":module_private_config", 766 ":module_mock_private_config", 767 "${powermgr_utils_path}:coverage_flags", 768 ] 769 770 deps = [ 771 "${powermgr_inner_api}:powermgr_client", 772 "${powermgr_inner_api}:powermgr_proxy", 773 "${powermgr_inner_api}:powermgr_stub", 774 "${powermgr_service_path}:powermgrservice", 775 ] 776 777 external_deps = deps_ex 778} 779 780ohos_unittest("test_mock_proxy") { 781 module_out_path = module_output_path 782 783 sources = [ 784 "mock/mock_message_parcel.cpp", 785 "mock/mock_parcel.cpp", 786 "src/mock/power_mock_proxy_test.cpp", 787 ] 788 789 sanitize = { 790 cfi = true 791 cfi_cross_dso = true 792 debug = false 793 blocklist = "../cfi_blocklist.txt" 794 } 795 796 configs = [ 797 "${powermgr_utils_path}:utils_config", 798 ":module_private_config", 799 ":module_mock_private_config", 800 "${powermgr_utils_path}:coverage_flags", 801 ] 802 803 defines += [ 804 "MOCK_WRITE_INTERFACE_TOKEN_RETURN_TRUE", 805 "MOCK_MOCK_READSTRING_DESCRIPTIR", 806 ] 807 808 deps = [ 809 "${powermgr_inner_api}:powermgr_client", 810 "${powermgr_inner_api}:powermgr_proxy", 811 "${powermgr_inner_api}:powermgr_stub", 812 "${powermgr_service_path}:powermgrservice", 813 ] 814 815 external_deps = deps_ex 816} 817 818ohos_unittest("power_state_machine_native_test") { 819 module_out_path = module_output_path 820 defines += defs 821 822 sources = [ "src/native_power_state_machine_test.cpp" ] 823 824 sanitize = { 825 cfi = true 826 cfi_cross_dso = true 827 debug = false 828 blocklist = "../cfi_blocklist.txt" 829 } 830 831 configs = [ 832 "${powermgr_utils_path}:utils_config", 833 ":module_private_config", 834 "${powermgr_utils_path}:coverage_flags", 835 ] 836 837 deps = [ 838 "${powermgr_inner_api}:powermgr_client", 839 "${powermgr_inner_api}:powermgr_stub", 840 "${powermgr_service_path}:powermgrservice", 841 ] 842 843 external_deps = deps_ex 844} 845 846ohos_unittest("test_running_lock_native") { 847 module_out_path = module_output_path 848 defines += defs 849 850 sources = [ "src/running_lock_native_test.cpp" ] 851 852 sanitize = { 853 cfi = true 854 cfi_cross_dso = true 855 debug = false 856 blocklist = "../cfi_blocklist.txt" 857 } 858 859 configs = [ 860 "${powermgr_utils_path}:utils_config", 861 ":module_private_config", 862 "${powermgr_utils_path}:coverage_flags", 863 ] 864 865 deps = [ 866 "${powermgr_inner_api}:powermgr_client", 867 "${powermgr_inner_api}:powermgr_stub", 868 "${powermgr_service_path}:powermgrservice", 869 ] 870 871 external_deps = deps_ex 872} 873 874ohos_unittest("test_power_mgr_service_native") { 875 module_out_path = module_output_path 876 defines += defs 877 878 sanitize = { 879 cfi = true 880 cfi_cross_dso = true 881 debug = false 882 blocklist = "../cfi_blocklist.txt" 883 } 884 885 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 886 defines += [ "THERMAL_GTEST" ] 887 888 sources = [ "src/power_mgr_service_native_test.cpp" ] 889 890 configs = [ 891 "${powermgr_utils_path}:utils_config", 892 ":module_private_config", 893 "${powermgr_utils_path}:coverage_flags", 894 ] 895 896 deps = [ 897 "${powermgr_inner_api}:powermgr_client", 898 "${powermgr_inner_api}:powermgr_stub", 899 "${powermgr_service_path}:powermgrservice", 900 ] 901 902 external_deps = [ 903 "data_share:datashare_common", 904 "data_share:datashare_consumer", 905 ] 906 external_deps += deps_ex 907} 908 909ohos_unittest("test_device_state_action_native") { 910 module_out_path = module_output_path 911 defines += defs 912 913 sanitize = { 914 cfi = true 915 cfi_cross_dso = true 916 debug = false 917 blocklist = "../cfi_blocklist.txt" 918 } 919 920 sources = [ "src/device_state_action_native_test.cpp" ] 921 922 configs = [ 923 "${powermgr_utils_path}:utils_config", 924 ":module_private_config", 925 "${powermgr_utils_path}:coverage_flags", 926 ] 927 928 deps = [ 929 "${powermgr_inner_api}:powermgr_client", 930 "${powermgr_inner_api}:powermgr_stub", 931 "${powermgr_service_path}:powermgrservice", 932 ] 933 934 if (has_display_manager_part) { 935 deps_ex += [ "display_manager:displaymgr" ] 936 } 937 deps_ex += [ "window_manager:libdm_lite" ] 938 external_deps = deps_ex 939} 940 941ohos_unittest("test_power_mgr_dump") { 942 module_out_path = module_output_path 943 944 sources = [ "src/power_mgr_dump_test.cpp" ] 945 946 configs = [ 947 "${powermgr_utils_path}:utils_config", 948 ":module_private_config", 949 "${powermgr_utils_path}:coverage_flags", 950 ] 951 952 deps = [ 953 "${powermgr_inner_api}:powermgr_client", 954 "${powermgr_service_path}:powermgrservice", 955 ] 956 957 external_deps = deps_ex 958} 959 960ohos_unittest("test_power_mgr_client_native") { 961 module_out_path = module_output_path 962 defines += defs 963 964 sanitize = { 965 cfi = true 966 cfi_cross_dso = true 967 debug = false 968 blocklist = "../cfi_blocklist.txt" 969 } 970 971 sources = [ "src/power_mgr_client_native_test.cpp" ] 972 973 configs = [ 974 "${powermgr_utils_path}:utils_config", 975 ":module_private_config", 976 "${powermgr_utils_path}:coverage_flags", 977 ] 978 979 deps = [ 980 "${powermgr_inner_api}:powermgr_client", 981 "${powermgr_inner_api}:powermgr_stub", 982 "${powermgr_service_path}:powermgrservice", 983 ] 984 985 external_deps = deps_ex 986} 987 988ohos_unittest("power_mode_module_native_test") { 989 module_out_path = module_output_path 990 defines += defs 991 992 sanitize = { 993 cfi = true 994 cfi_cross_dso = true 995 debug = false 996 blocklist = "../cfi_blocklist.txt" 997 } 998 999 sources = [ "src/power_mode_module_native_test.cpp" ] 1000 configs = [ 1001 "${powermgr_utils_path}:utils_config", 1002 ":module_private_config", 1003 "${powermgr_utils_path}:coverage_flags", 1004 ] 1005 deps = [ 1006 "${powermgr_inner_api}:powermgr_client", 1007 "${powermgr_inner_api}:powermgr_stub", 1008 "${powermgr_service_path}:powermgrservice", 1009 ] 1010 external_deps = deps_ex 1011} 1012 1013ohos_unittest("test_running_lock_hub_native") { 1014 module_out_path = module_output_path 1015 defines += defs 1016 1017 sanitize = { 1018 cfi = true 1019 cfi_cross_dso = true 1020 debug = false 1021 blocklist = "../cfi_blocklist.txt" 1022 } 1023 1024 include_dirs = 1025 [ "${powermgr_service_path}/native/src/actions/default/suspend" ] 1026 1027 sources = [ "src/running_lock_hub_native_test.cpp" ] 1028 1029 configs = [ 1030 "${powermgr_utils_path}:utils_config", 1031 ":module_private_config", 1032 "${powermgr_utils_path}:coverage_flags", 1033 ] 1034 1035 defines += [ "THERMAL_GTEST" ] 1036 1037 deps = [ 1038 "${powermgr_inner_api}:powermgr_client", 1039 "${powermgr_inner_api}:powermgr_stub", 1040 "${powermgr_service_path}:powermgrservice", 1041 ] 1042 1043 external_deps = deps_ex 1044} 1045 1046ohos_unittest("test_running_lock_mock") { 1047 module_out_path = module_output_path 1048 1049 sanitize = { 1050 cfi = true 1051 cfi_cross_dso = true 1052 debug = false 1053 blocklist = "../cfi_blocklist.txt" 1054 } 1055 1056 sources = [ "src/running_lock_mock_test.cpp" ] 1057 1058 configs = [ 1059 "${powermgr_utils_path}:utils_config", 1060 ":module_private_config", 1061 "${powermgr_utils_path}:coverage_flags", 1062 ] 1063 1064 deps = [ 1065 "${powermgr_inner_api}:powermgr_client", 1066 "${powermgr_inner_api}:powermgr_stub", 1067 "${powermgr_service_path}:powermgrservice", 1068 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1069 ] 1070 1071 external_deps = deps_ex 1072} 1073 1074ohos_unittest("test_power_suspend_parse") { 1075 module_out_path = module_output_path 1076 1077 sanitize = { 1078 cfi = true 1079 cfi_cross_dso = true 1080 debug = false 1081 blocklist = "../cfi_blocklist.txt" 1082 } 1083 1084 sources = [ "src/interface_test/power_suspend_parse_test.cpp" ] 1085 1086 configs = [ 1087 "${powermgr_utils_path}:utils_config", 1088 ":module_private_config", 1089 "${powermgr_utils_path}:coverage_flags", 1090 ] 1091 1092 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1093 1094 defines += [ "THERMAL_GTEST" ] 1095 1096 deps = [ 1097 "${powermgr_inner_api}:powermgr_client", 1098 "${powermgr_inner_api}:powermgr_stub", 1099 "${powermgr_service_path}:powermgrservice", 1100 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1101 "${powermgr_utils_path}/setting:power_setting", 1102 ] 1103 1104 external_deps = [ 1105 "ability_base:zuri", 1106 "ability_runtime:ability_manager", 1107 "c_utils:utils", 1108 "data_share:datashare_common", 1109 "data_share:datashare_consumer", 1110 "hilog:libhilog", 1111 "ipc:ipc_core", 1112 "samgr:samgr_proxy", 1113 ] 1114 external_deps += deps_ex 1115} 1116 1117ohos_unittest("test_power_wakeup_parse") { 1118 module_out_path = module_output_path 1119 1120 sanitize = { 1121 cfi = true 1122 cfi_cross_dso = true 1123 debug = false 1124 blocklist = "../cfi_blocklist.txt" 1125 } 1126 1127 sources = [ "src/interface_test/power_wakeup_parse_test.cpp" ] 1128 1129 configs = [ 1130 "${powermgr_utils_path}:utils_config", 1131 ":module_private_config", 1132 "${powermgr_utils_path}:coverage_flags", 1133 ] 1134 1135 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1136 1137 defines += [ "THERMAL_GTEST" ] 1138 1139 deps = [ 1140 "${powermgr_inner_api}:powermgr_client", 1141 "${powermgr_inner_api}:powermgr_stub", 1142 "${powermgr_service_path}:powermgrservice", 1143 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1144 "${powermgr_utils_path}/setting:power_setting", 1145 ] 1146 1147 external_deps = [ 1148 "ability_base:zuri", 1149 "ability_runtime:ability_manager", 1150 "c_utils:utils", 1151 "data_share:datashare_common", 1152 "data_share:datashare_consumer", 1153 "hilog:libhilog", 1154 "ipc:ipc_core", 1155 "samgr:samgr_proxy", 1156 ] 1157 external_deps += deps_ex 1158} 1159 1160ohos_unittest("test_power_suspend_controller") { 1161 module_out_path = module_output_path 1162 1163 sanitize = { 1164 cfi = true 1165 cfi_cross_dso = true 1166 debug = false 1167 blocklist = "../cfi_blocklist.txt" 1168 } 1169 1170 sources = [ "src/interface_test/power_suspend_controller_test.cpp" ] 1171 1172 configs = [ 1173 "${powermgr_utils_path}:utils_config", 1174 ":module_private_config", 1175 ":module_mock_private_config", 1176 "${powermgr_utils_path}:coverage_flags", 1177 ] 1178 1179 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1180 1181 defines += [ "POWERMGR_GTEST" ] 1182 1183 deps = [ 1184 "${powermgr_inner_api}:powermgr_client", 1185 "${powermgr_inner_api}:powermgr_stub", 1186 "${powermgr_service_path}:powermgrservice", 1187 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1188 "${powermgr_utils_path}/setting:power_setting", 1189 ] 1190 1191 external_deps = [ 1192 "ability_base:zuri", 1193 "ability_runtime:ability_manager", 1194 "c_utils:utils", 1195 "data_share:datashare_common", 1196 "data_share:datashare_consumer", 1197 "hilog:libhilog", 1198 "ipc:ipc_core", 1199 "samgr:samgr_proxy", 1200 ] 1201 external_deps += deps_ex 1202 1203 if (power_manager_feature_force_sleep_broadcast) { 1204 defines += [ "POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST" ] 1205 } 1206} 1207 1208ohos_unittest("test_power_suspend") { 1209 module_out_path = module_output_path 1210 1211 sanitize = { 1212 cfi = true 1213 cfi_cross_dso = true 1214 debug = false 1215 blocklist = "../cfi_blocklist.txt" 1216 } 1217 1218 sources = [ "src/scenario_test/wakeup_suspend/power_suspend_test.cpp" ] 1219 1220 configs = [ 1221 "${powermgr_utils_path}:utils_config", 1222 ":module_private_config", 1223 ":module_mock_private_config", 1224 "${powermgr_utils_path}:coverage_flags", 1225 ] 1226 1227 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1228 1229 defines += [ "POWERMGR_GTEST" ] 1230 1231 deps = [ 1232 "${powermgr_inner_api}:powermgr_client", 1233 "${powermgr_inner_api}:powermgr_stub", 1234 "${powermgr_service_path}:powermgrservice", 1235 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1236 "${powermgr_utils_path}/setting:power_setting", 1237 ] 1238 1239 external_deps = [ 1240 "ability_base:zuri", 1241 "ability_runtime:ability_manager", 1242 "c_utils:utils", 1243 "data_share:datashare_common", 1244 "data_share:datashare_consumer", 1245 "hilog:libhilog", 1246 "ipc:ipc_core", 1247 "samgr:samgr_proxy", 1248 ] 1249 external_deps += deps_ex 1250 1251 if (power_manager_feature_force_sleep_broadcast) { 1252 defines += [ "POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST" ] 1253 } 1254} 1255 1256ohos_unittest("test_power_wakeup_controller") { 1257 module_out_path = module_output_path 1258 1259 sanitize = { 1260 cfi = true 1261 cfi_cross_dso = true 1262 debug = false 1263 blocklist = "../cfi_blocklist.txt" 1264 } 1265 1266 sources = [ "src/interface_test/power_wakeup_controller_test.cpp" ] 1267 1268 configs = [ 1269 "${powermgr_utils_path}:utils_config", 1270 ":module_private_config", 1271 ":module_mock_private_config", 1272 "${powermgr_utils_path}:coverage_flags", 1273 ] 1274 1275 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1276 1277 defines += [ "POWERMGR_GTEST" ] 1278 1279 deps = [ 1280 "${powermgr_inner_api}:powermgr_client", 1281 "${powermgr_inner_api}:powermgr_stub", 1282 "${powermgr_service_path}:powermgrservice", 1283 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1284 "${powermgr_utils_path}/setting:power_setting", 1285 ] 1286 1287 external_deps = [ 1288 "ability_base:zuri", 1289 "ability_runtime:ability_manager", 1290 "c_utils:utils", 1291 "data_share:datashare_common", 1292 "data_share:datashare_consumer", 1293 "hilog:libhilog", 1294 "ipc:ipc_core", 1295 "samgr:samgr_proxy", 1296 ] 1297 external_deps += deps_ex 1298} 1299 1300ohos_unittest("test_power_wakeup_controller_oninputevent") { 1301 module_out_path = module_output_path 1302 1303 sanitize = { 1304 cfi = true 1305 cfi_cross_dso = true 1306 debug = false 1307 blocklist = "../cfi_blocklist.txt" 1308 } 1309 1310 sources = [ "src/interface_test/power_wakeup_controller_oninput_test.cpp" ] 1311 1312 configs = [ 1313 "${powermgr_utils_path}:utils_config", 1314 ":module_private_config", 1315 ":module_mock_private_config", 1316 "${powermgr_utils_path}:coverage_flags", 1317 ] 1318 1319 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1320 1321 defines += [ "POWERMGR_GTEST" ] 1322 1323 deps = [ 1324 "${powermgr_inner_api}:powermgr_client", 1325 "${powermgr_service_path}:powermgrservice", 1326 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1327 "${powermgr_inner_api}:powermgr_stub", 1328 "${powermgr_utils_path}/setting:power_setting", 1329 ] 1330 1331 external_deps = [ 1332 "ability_base:zuri", 1333 "ability_runtime:ability_manager", 1334 "c_utils:utils", 1335 "hilog:libhilog", 1336 "ipc:ipc_core", 1337 "samgr:samgr_proxy", 1338 ] 1339 external_deps += deps_ex 1340} 1341 1342ohos_unittest("test_power_wakeup") { 1343 module_out_path = module_output_path 1344 1345 sanitize = { 1346 cfi = true 1347 cfi_cross_dso = true 1348 debug = false 1349 blocklist = "../cfi_blocklist.txt" 1350 } 1351 1352 sources = [ "src/scenario_test/wakeup_suspend/power_wakeup_test.cpp" ] 1353 1354 configs = [ 1355 "${powermgr_utils_path}:utils_config", 1356 ":module_private_config", 1357 ":module_mock_private_config", 1358 "${powermgr_utils_path}:coverage_flags", 1359 ] 1360 1361 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1362 1363 defines += [ "POWERMGR_GTEST" ] 1364 1365 deps = [ 1366 "${powermgr_inner_api}:powermgr_client", 1367 "${powermgr_inner_api}:powermgr_stub", 1368 "${powermgr_service_path}:powermgrservice", 1369 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1370 "${powermgr_utils_path}/setting:power_setting", 1371 ] 1372 1373 external_deps = [ 1374 "ability_base:zuri", 1375 "ability_runtime:ability_manager", 1376 "c_utils:utils", 1377 "data_share:datashare_common", 1378 "data_share:datashare_consumer", 1379 "hilog:libhilog", 1380 "ipc:ipc_core", 1381 "samgr:samgr_proxy", 1382 ] 1383 external_deps += deps_ex 1384} 1385 1386ohos_unittest("test_power_shutdown_clinet") { 1387 module_out_path = module_output_path 1388 1389 sources = [ "src/interface_test/shutdown_client_test.cpp" ] 1390 1391 configs = [ 1392 "${powermgr_utils_path}:utils_config", 1393 ":module_private_config", 1394 "${powermgr_utils_path}:coverage_flags", 1395 ] 1396 1397 deps = [ 1398 "${powermgr_inner_api}:powermgr_client", 1399 "${powermgr_service_path}:powermgrservice", 1400 ] 1401 external_deps = deps_ex 1402} 1403 1404ohos_unittest("test_power_suspend_takeover") { 1405 module_out_path = module_output_path 1406 1407 sources = [ "src/interface_test/suspend_takeover_client_test.cpp" ] 1408 1409 configs = [ 1410 "${powermgr_utils_path}:utils_config", 1411 ":module_private_config", 1412 "${powermgr_utils_path}:coverage_flags", 1413 ] 1414 1415 deps = [ 1416 "${powermgr_inner_api}:powermgr_client", 1417 "${powermgr_service_path}:powermgrservice", 1418 ] 1419 external_deps = deps_ex 1420} 1421 1422ohos_unittest("test_power_getcontroller_mock") { 1423 module_out_path = module_output_path 1424 1425 sanitize = { 1426 cfi = true 1427 cfi_cross_dso = true 1428 debug = false 1429 blocklist = "../cfi_blocklist.txt" 1430 } 1431 1432 sources = [ "src/power_getcontroller_mock_test.cpp" ] 1433 1434 configs = [ 1435 "${powermgr_utils_path}:utils_config", 1436 ":module_private_config", 1437 ":module_mock_private_config", 1438 "${powermgr_utils_path}:coverage_flags", 1439 ] 1440 1441 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1442 1443 defines += [ "POWERMGR_GTEST" ] 1444 1445 deps = [ 1446 "${powermgr_inner_api}:powermgr_client", 1447 "${powermgr_inner_api}:powermgr_stub", 1448 "${powermgr_service_path}:powermgrservice", 1449 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1450 "${powermgr_utils_path}/permission:power_permission", 1451 "${powermgr_utils_path}/setting:power_setting", 1452 ] 1453 1454 external_deps = [ 1455 "ability_base:zuri", 1456 "ability_runtime:ability_manager", 1457 "c_utils:utils", 1458 "data_share:datashare_common", 1459 "data_share:datashare_consumer", 1460 "ipc:ipc_core", 1461 "samgr:samgr_proxy", 1462 ] 1463 external_deps += deps_ex 1464} 1465 1466ohos_unittest("test_power_screenon_mock") { 1467 module_out_path = module_output_path 1468 1469 sanitize = { 1470 cfi = true 1471 cfi_cross_dso = true 1472 debug = false 1473 blocklist = "../cfi_blocklist.txt" 1474 } 1475 1476 sources = [ "src/power_screenon_mock_test.cpp" ] 1477 1478 configs = [ 1479 "${powermgr_utils_path}:utils_config", 1480 ":module_private_config", 1481 ":module_mock_private_config", 1482 "${powermgr_utils_path}:coverage_flags", 1483 ] 1484 1485 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1486 1487 defines += [ "POWERMGR_GTEST" ] 1488 1489 deps = [ 1490 "${powermgr_inner_api}:powermgr_client", 1491 "${powermgr_inner_api}:powermgr_stub", 1492 "${powermgr_service_path}:powermgrservice", 1493 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1494 "${powermgr_utils_path}/permission:power_permission", 1495 "${powermgr_utils_path}/setting:power_setting", 1496 ] 1497 1498 external_deps = [ 1499 "ability_base:zuri", 1500 "ability_runtime:ability_manager", 1501 "c_utils:utils", 1502 "data_share:datashare_common", 1503 "data_share:datashare_consumer", 1504 "ipc:ipc_core", 1505 "samgr:samgr_proxy", 1506 ] 1507 external_deps += deps_ex 1508} 1509 1510ohos_unittest("test_power_parsesources_mock") { 1511 module_out_path = module_output_path 1512 1513 sanitize = { 1514 cfi = true 1515 cfi_cross_dso = true 1516 debug = false 1517 blocklist = "../cfi_blocklist.txt" 1518 } 1519 1520 sources = [ "src/power_parsesources_mock_test.cpp" ] 1521 1522 configs = [ 1523 "${powermgr_utils_path}:utils_config", 1524 ":module_private_config", 1525 ":module_mock_private_config", 1526 "${powermgr_utils_path}:coverage_flags", 1527 ] 1528 1529 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1530 1531 deps = [ 1532 "${powermgr_inner_api}:powermgr_client", 1533 "${powermgr_inner_api}:powermgr_stub", 1534 "${powermgr_service_path}:powermgrservice", 1535 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1536 "${powermgr_utils_path}/permission:power_permission", 1537 "${powermgr_utils_path}/setting:power_setting", 1538 ] 1539 1540 external_deps = [ 1541 "ability_base:zuri", 1542 "ability_runtime:ability_manager", 1543 "c_utils:utils", 1544 "data_share:datashare_common", 1545 "data_share:datashare_consumer", 1546 "ipc:ipc_core", 1547 "samgr:samgr_proxy", 1548 ] 1549 external_deps += deps_ex 1550} 1551 1552################################powermgrdialog################################ 1553 1554ohos_unittest("test_power_mgr_powerdialog") { 1555 module_out_path = module_output_path 1556 1557 sanitize = { 1558 cfi = true 1559 cfi_cross_dso = true 1560 debug = false 1561 blocklist = "../cfi_blocklist.txt" 1562 } 1563 1564 sources = [ 1565 "mock/mock_power_remote_object.cpp", 1566 "src/power_mgr_powerdialog_test.cpp", 1567 ] 1568 1569 configs = [ 1570 "${powermgr_utils_path}:utils_config", 1571 ":module_private_config", 1572 "${powermgr_utils_path}:coverage_flags", 1573 ] 1574 1575 deps = [ 1576 "${powermgr_inner_api}:powermgr_client", 1577 "${powermgr_inner_api}:powermgr_stub", 1578 "${powermgr_service_path}:powermgrservice", 1579 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1580 "${powermgr_utils_path}/param:power_sysparam", 1581 "${powermgr_utils_path}/permission:power_permission", 1582 "${powermgr_utils_path}/setting:power_setting", 1583 ] 1584 1585 external_deps = deps_ex 1586 1587 external_deps += [ "libxml2:libxml2" ] 1588} 1589 1590##############################coordination_lock_test############################# 1591 1592ohos_unittest("test_power_coordination_lock") { 1593 module_out_path = module_output_path 1594 1595 sources = [ "src/power_coordination_lock_test.cpp" ] 1596 1597 sanitize = { 1598 cfi = true 1599 cfi_cross_dso = true 1600 debug = false 1601 blocklist = "../cfi_blocklist.txt" 1602 } 1603 1604 configs = [ 1605 "${powermgr_utils_path}:utils_config", 1606 ":module_private_config", 1607 "${powermgr_utils_path}:coverage_flags", 1608 ] 1609 1610 deps = [ 1611 "${powermgr_inner_api}:powermgr_client", 1612 "${powermgr_inner_api}:powermgr_stub", 1613 "${powermgr_service_path}:powermgrservice", 1614 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1615 ] 1616 1617 external_deps = deps_ex 1618} 1619 1620##############################running_lock_timer_handler_test############################# 1621ohos_unittest("test_running_lock_timer_handler") { 1622 module_out_path = module_output_path 1623 1624 sources = [ 1625 "${powermgr_service_path}/native/src/runninglock/running_lock_timer_handler.cpp", 1626 "src/running_lock_timer_handler_test.cpp", 1627 ] 1628 1629 configs = [ 1630 "${powermgr_utils_path}:utils_config", 1631 ":module_private_config", 1632 "${powermgr_utils_path}:coverage_flags", 1633 ] 1634 1635 deps = [ "${powermgr_inner_api}:powermgr_client" ] 1636 1637 external_deps = deps_ex 1638} 1639 1640##############################test_device_power_action############################## 1641ohos_unittest("test_device_power_action") { 1642 module_out_path = module_output_path 1643 1644 sanitize = { 1645 cfi = true 1646 cfi_cross_dso = true 1647 debug = false 1648 blocklist = "../cfi_blocklist.txt" 1649 } 1650 1651 sources = [ 1652 "${powermgr_service_path}/native/src/power_hdi_callback.cpp", 1653 "src/device_power_action_test.cpp", 1654 ] 1655 1656 configs = [ 1657 "${powermgr_utils_path}:utils_config", 1658 ":module_private_config", 1659 "${powermgr_utils_path}:coverage_flags", 1660 ] 1661 deps = [ 1662 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1663 "${powermgr_utils_path}/hookmgr:power_hookmgr", 1664 ] 1665 external_deps = deps_ex 1666 external_deps += [ 1667 "drivers_interface_power:libpower_proxy_1.2", 1668 "drivers_interface_power:libpower_proxy_1.3", 1669 "init:libbegetutil", 1670 ] 1671} 1672 1673##############################test_power_config_parse.############################# 1674ohos_unittest("test_power_config_parse") { 1675 sanitize = { 1676 cfi = true 1677 cfi_cross_dso = true 1678 debug = false 1679 blocklist = "../cfi_blocklist.txt" 1680 } 1681 1682 module_out_path = module_output_path 1683 1684 cflags = [ 1685 "-Dprivate=public", 1686 "-Dprotected=public", 1687 ] 1688 1689 sources = [ "src/power_config_parse_test.cpp" ] 1690 1691 configs = [ 1692 "${powermgr_utils_path}:utils_config", 1693 ":module_private_config", 1694 ":module_mock_private_config", 1695 "${powermgr_utils_path}:coverage_flags", 1696 ] 1697 1698 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1699 1700 deps = [ 1701 "${powermgr_inner_api}:powermgr_client", 1702 "${powermgr_inner_api}:powermgr_stub", 1703 "${powermgr_service_path}:powermgrservice", 1704 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1705 "${powermgr_utils_path}/setting:power_setting", 1706 "${powermgr_utils_path}/vibrator:power_vibrator", 1707 ] 1708 1709 external_deps = [ 1710 "ability_base:zuri", 1711 "ability_runtime:ability_manager", 1712 "c_utils:utils", 1713 "data_share:datashare_common", 1714 "data_share:datashare_consumer", 1715 "ipc:ipc_core", 1716 "samgr:samgr_proxy", 1717 ] 1718 external_deps += deps_ex 1719 1720 if (power_manager_feature_doubleclick) { 1721 defines += [ "POWER_DOUBLECLICK_ENABLE" ] 1722 } 1723 1724 if (power_manager_feature_pickup) { 1725 defines += [ "POWER_PICKUP_ENABLE" ] 1726 } 1727} 1728 1729##############################test_power_config_parse_two.############################# 1730ohos_unittest("test_power_config_parse_two") { 1731 module_out_path = module_output_path 1732 1733 sanitize = { 1734 cfi = true 1735 cfi_cross_dso = true 1736 debug = false 1737 blocklist = "../cfi_blocklist.txt" 1738 } 1739 1740 cflags = [ 1741 "-Dprivate=public", 1742 "-Dprotected=public", 1743 ] 1744 1745 sources = [ 1746 "src/power_config_parse_test_two.cpp", 1747 ] 1748 1749 configs = [ 1750 "${powermgr_utils_path}:utils_config", 1751 ":module_private_config", 1752 ":module_mock_private_config", 1753 "${powermgr_utils_path}:coverage_flags", 1754 ] 1755 1756 include_dirs = [ "${powermgr_service_path}/native/src/setting/" ] 1757 1758 deps = [ 1759 "${powermgr_inner_api}:powermgr_client", 1760 "${powermgr_inner_api}:powermgr_stub", 1761 "${powermgr_service_path}:powermgrservice", 1762 "${powermgr_service_path}/native/src/actions:powermgr_actions", 1763 "${powermgr_utils_path}/setting:power_setting", 1764 "${powermgr_utils_path}/vibrator:power_vibrator", 1765 ] 1766 1767 external_deps = [ 1768 "ability_base:zuri", 1769 "ability_runtime:ability_manager", 1770 "c_utils:utils", 1771 "data_share:datashare_common", 1772 "data_share:datashare_consumer", 1773 "ipc:ipc_core", 1774 "samgr:samgr_proxy", 1775 ] 1776 external_deps += deps_ex 1777 1778 if (power_manager_feature_doubleclick) { 1779 defines += [ "POWER_DOUBLECLICK_ENABLE" ] 1780 } 1781 1782 if (power_manager_feature_pickup) { 1783 defines += [ "POWER_PICKUP_ENABLE" ] 1784 } 1785} 1786 1787if (power_manager_feature_surport_takeover_suspend) { 1788 defines += [ "POWER_MANAGER_TAKEOVER_SUSPEND" ] 1789} 1790 1791group("unittest") { 1792 testonly = true 1793 deps = [ 1794 ":power_client_callback_test", 1795 ":power_mode_module_native_test", 1796 ":power_state_machine_native_test", 1797 ":test_device_power_action", 1798 ":test_mock_parcel", 1799 ":test_mock_peer", 1800 ":test_mock_proxy", 1801 ":test_power_config_parse", 1802 ":test_power_config_parse_two", 1803 ":test_power_coordination_lock", 1804 ":test_power_device_mode", 1805 ":test_power_getcontroller_mock", 1806 ":test_power_key_option", 1807 ":test_power_mgr_client", 1808 ":test_power_mgr_client_native", 1809 ":test_power_mgr_dump", 1810 ":test_power_mgr_mock", 1811 ":test_power_mgr_power_appmgr", 1812 ":test_power_mgr_power_intf_wrapper", 1813 ":test_power_mgr_power_lib_loader", 1814 ":test_power_mgr_powerdialog", 1815 ":test_power_mgr_service", 1816 ":test_power_mgr_service_death", 1817 ":test_power_mgr_service_native", 1818 ":test_power_mgr_util", 1819 ":test_power_mock_object", 1820 ":test_power_parsesources_mock", 1821 ":test_power_screenon_mock", 1822 ":test_power_set_mode", 1823 ":test_power_shutdown_clinet", 1824 ":test_power_state_level_framework", 1825 ":test_power_state_machine", 1826 ":test_power_suspend", 1827 ":test_power_suspend_controller", 1828 ":test_power_suspend_parse", 1829 ":test_power_wakeup", 1830 ":test_power_wakeup_controller", 1831 ":test_power_wakeup_controller_oninputevent", 1832 ":test_power_wakeup_parse", 1833 ":test_running_lock", 1834 ":test_running_lock_hub_native", 1835 ":test_running_lock_mock", 1836 ":test_running_lock_native", 1837 ":test_running_lock_scenario", 1838 ":test_running_lock_timer_handler", 1839 ] 1840 if (power_manager_feature_surport_takeover_suspend) { 1841 deps += [ 1842 ":test_power_mgr_service_ipc_adapter", 1843 ":test_power_suspend_takeover", 1844 ] 1845 } 1846 if (has_display_manager_part) { 1847 deps += [ ":test_device_state_action_native" ] 1848 } 1849} 1850 1851group("unittest_ex") { 1852 testonly = true 1853 deps = [ "src/scenario_test:scenario_test" ] 1854} 1855