1# Copyright (c) 2023-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/ohos.gni")
15import("//build/test.gni")
16import("//foundation/resourceschedule/device_standby/standby_service.gni")
17
18module_output_path = "${standby_service_part_name}/unittest"
19
20ohos_unittest("standby_service_unit_test") {
21  module_out_path = module_output_path
22  cflags_cc = [
23    "-Dprivate=public",
24    "-Dprotected=public",
25  ]
26
27  include_dirs = [ "${standby_service_path}/test/unittest/mock/include" ]
28
29  sources = [
30    "mock/mock_common_event.cpp",
31    "mock/mock_helper.cpp",
32    "mock/mock_ipc.cpp",
33    "standby_service_unit_test.cpp",
34  ]
35
36  deps = [
37    "${standby_innerkits_path}:standby_innerkits",
38    "${standby_plugins_path}:standby_plugin_static",
39    "${standby_service_frameworks_path}:standby_fwk",
40    "${standby_service_path}:standby_service_static",
41    "${standby_utils_common_path}:standby_utils_common",
42    "${standby_utils_policy_path}:standby_utils_policy_static",
43  ]
44
45  external_deps = [
46    "ability_base:base",
47    "ability_base:want",
48    "ability_base:zuri",
49    "ability_runtime:app_manager",
50    "ability_runtime:wantagent_innerkits",
51    "access_token:libaccesstoken_sdk",
52    "access_token:libtokenid_sdk",
53    "bundle_framework:appexecfwk_base",
54    "c_utils:utils",
55    "common_event_service:cesfwk_innerkits",
56    "eventhandler:libeventhandler",
57    "hilog:libhilog",
58    "init:libbegetutil",
59    "ipc:ipc_single",
60    "safwk:system_ability_fwk",
61    "samgr:samgr_proxy",
62    "time_service:time_client",
63  ]
64
65  defines = []
66  if (enable_background_task_mgr) {
67    external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ]
68    defines += [ "ENABLE_BACKGROUND_TASK_MGR" ]
69  }
70
71  if (standby_power_manager_enable) {
72    external_deps += [ "power_manager:powermgr_client" ]
73    defines += [ "STANDBY_POWER_MANAGER_ENABLE" ]
74  }
75
76  subsystem_name = "resourceschedule"
77  part_name = "${standby_service_part_name}"
78}
79
80ohos_unittest("standby_utils_unit_test") {
81  module_out_path = module_output_path
82  cflags_cc = [
83    "-Dprivate=public",
84    "-Dprotected=public",
85  ]
86
87  include_dirs = [ "${standby_service_path}/test/unittest/mock/include" ]
88
89  sanitize = {
90    cfi = true
91    cfi_cross_dso = true
92    debug = false
93  }
94
95  sources = [
96    "mock/mock_common_event.cpp",
97    "standby_utils_unit_test.cpp",
98  ]
99
100  deps = [
101    "${standby_service_path}:standby_service_static",
102    "${standby_utils_common_path}:standby_utils_common",
103    "${standby_utils_policy_path}:standby_utils_policy_static",
104  ]
105
106  external_deps = [
107    "ability_base:base",
108    "ability_base:want",
109    "ability_base:zuri",
110    "ability_runtime:app_manager",
111    "ability_runtime:wantagent_innerkits",
112    "access_token:libaccesstoken_sdk",
113    "access_token:libtokenid_sdk",
114    "bundle_framework:appexecfwk_base",
115    "c_utils:utils",
116    "common_event_service:cesfwk_innerkits",
117    "eventhandler:libeventhandler",
118    "hilog:libhilog",
119    "init:libbegetutil",
120    "ipc:ipc_single",
121    "safwk:system_ability_fwk",
122    "samgr:samgr_proxy",
123    "time_service:time_client",
124  ]
125
126  defines = []
127  if (enable_background_task_mgr) {
128    external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ]
129    defines += [ "ENABLE_BACKGROUND_TASK_MGR" ]
130  }
131
132  if (standby_power_manager_enable) {
133    external_deps += [ "power_manager:powermgr_client" ]
134    defines += [ "STANDBY_POWER_MANAGER_ENABLE" ]
135  }
136
137  subsystem_name = "resourceschedule"
138  part_name = "${standby_service_part_name}"
139}
140
141ohos_unittest("standby_helper_unit_test") {
142  module_out_path = module_output_path
143  cflags_cc = [
144    "-Dprivate=public",
145    "-Dprotected=public",
146  ]
147
148  include_dirs = [ "${standby_service_path}/test/unittest/mock/include" ]
149
150  sources = [
151    "allow_record_unit_test.cpp",
152    "mock/mock_helper.cpp",
153    "standby_helper_unit_test.cpp",
154  ]
155
156  deps = [
157    "${standby_service_path}:standby_service_static",
158    "${standby_utils_common_path}:standby_utils_common",
159    "${standby_utils_policy_path}:standby_utils_policy_static",
160  ]
161
162  external_deps = [
163    "ability_base:base",
164    "ability_base:want",
165    "ability_base:zuri",
166    "ability_runtime:app_manager",
167    "ability_runtime:wantagent_innerkits",
168    "access_token:libaccesstoken_sdk",
169    "access_token:libtokenid_sdk",
170    "bundle_framework:appexecfwk_base",
171    "c_utils:utils",
172    "common_event_service:cesfwk_innerkits",
173    "eventhandler:libeventhandler",
174    "hilog:libhilog",
175    "init:libbegetutil",
176    "ipc:ipc_single",
177    "safwk:system_ability_fwk",
178    "samgr:samgr_proxy",
179    "time_service:time_client",
180  ]
181
182  defines = []
183  if (enable_background_task_mgr) {
184    external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ]
185    defines += [ "ENABLE_BACKGROUND_TASK_MGR" ]
186  }
187
188  if (standby_power_manager_enable) {
189    external_deps += [ "power_manager:powermgr_client" ]
190    defines += [ "STANDBY_POWER_MANAGER_ENABLE" ]
191  }
192
193  subsystem_name = "resourceschedule"
194  part_name = "${standby_service_part_name}"
195}
196
197ohos_unittest("mock_standby_helper_unit_test") {
198  module_out_path = module_output_path
199  cflags_cc = [
200    "-Dprivate=public",
201    "-Dprotected=public",
202  ]
203
204  sources = [
205    "mock/mock_connect.cpp",
206    "mock/mock_standby_helper_unit_test.cpp",
207  ]
208
209  deps = [
210    "${standby_service_path}:standby_service_static",
211    "${standby_utils_common_path}:standby_utils_common",
212    "${standby_utils_policy_path}:standby_utils_policy_static",
213  ]
214
215  external_deps = [
216    "ability_base:base",
217    "ability_base:want",
218    "ability_base:zuri",
219    "ability_runtime:app_manager",
220    "ability_runtime:wantagent_innerkits",
221    "access_token:libaccesstoken_sdk",
222    "access_token:libtokenid_sdk",
223    "bundle_framework:appexecfwk_base",
224    "c_utils:utils",
225    "common_event_service:cesfwk_innerkits",
226    "eventhandler:libeventhandler",
227    "hilog:libhilog",
228    "init:libbegetutil",
229    "ipc:ipc_single",
230    "safwk:system_ability_fwk",
231    "samgr:samgr_proxy",
232    "time_service:time_client",
233  ]
234
235  defines = []
236  if (enable_background_task_mgr) {
237    external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ]
238    defines += [ "ENABLE_BACKGROUND_TASK_MGR" ]
239  }
240
241  if (standby_power_manager_enable) {
242    external_deps += [ "power_manager:powermgr_client" ]
243    defines += [ "STANDBY_POWER_MANAGER_ENABLE" ]
244  }
245
246  subsystem_name = "resourceschedule"
247  part_name = "${standby_service_part_name}"
248}
249
250ohos_unittest("mock_standby_service_unit_test") {
251  module_out_path = module_output_path
252  cflags_cc = [
253    "-Dprivate=public",
254    "-Dprotected=public",
255  ]
256
257  include_dirs = [ "${standby_service_path}/test/unittest/mock/include" ]
258
259  sources = [
260    "mock/mock_helper.cpp",
261    "mock_standby_service_unit_test.cpp",
262  ]
263
264  deps = [
265    "${standby_innerkits_path}:standby_innerkits",
266    "${standby_service_frameworks_path}:standby_fwk",
267    "${standby_service_path}:standby_service_static",
268    "${standby_utils_common_path}:standby_utils_common",
269    "${standby_utils_policy_path}:standby_utils_policy_static",
270    "//third_party/googletest:gmock_main",
271  ]
272
273  external_deps = [
274    "ability_base:base",
275    "ability_base:want",
276    "ability_base:zuri",
277    "ability_runtime:app_manager",
278    "ability_runtime:wantagent_innerkits",
279    "access_token:libaccesstoken_sdk",
280    "access_token:libtokenid_sdk",
281    "bundle_framework:appexecfwk_base",
282    "c_utils:utils",
283    "common_event_service:cesfwk_innerkits",
284    "eventhandler:libeventhandler",
285    "hilog:libhilog",
286    "init:libbegetutil",
287    "ipc:ipc_single",
288    "safwk:system_ability_fwk",
289    "samgr:samgr_proxy",
290    "time_service:time_client",
291  ]
292
293  defines = []
294  if (enable_background_task_mgr) {
295    external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ]
296    defines += [ "ENABLE_BACKGROUND_TASK_MGR" ]
297  }
298
299  if (standby_power_manager_enable) {
300    external_deps += [ "power_manager:powermgr_client" ]
301    defines += [ "STANDBY_POWER_MANAGER_ENABLE" ]
302  }
303
304  subsystem_name = "resourceschedule"
305  part_name = "${standby_service_part_name}"
306}
307
308group("unittest") {
309  testonly = true
310
311  deps = [
312    ":mock_standby_helper_unit_test",
313    ":mock_standby_service_unit_test",
314    ":standby_helper_unit_test",
315    ":standby_utils_unit_test",
316  ]
317  if (device_standby_plugin_enable) {
318    deps += [ ":standby_service_unit_test" ]
319  }
320}
321