1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
17
18 #define protected public
19 #include "ipolicy_query.h"
20 #undef protected
21
22 #ifdef FEATURE_PC_ONLY
23 #include "disallow_modify_ethernet_ip_query.h"
24 #endif
25
26 #ifdef PRIVATE_SPACE_EDM_ENABLE
27 #include "disable_private_space_query.h"
28 #endif
29
30 #include "allowed_app_distribution_types_query.h"
31 #include "allowed_bluetooth_devices_query.h"
32 #include "allowed_usb_devices_query.h"
33 #include "allowed_wifi_list_query.h"
34 #include "cJSON.h"
35 #include "cjson_serializer.h"
36 #include "clipboard_info.h"
37 #include "clipboard_policy.h"
38 #include "clipboard_policy_query.h"
39 #include "clipboard_policy_serializer.h"
40 #include "disable_backup_and_restore_query.h"
41 #include "disable_bluetooth_query.h"
42 #include "disable_camera_query.h"
43 #include "disable_hdc_query.h"
44 #include "disable_microphone_query.h"
45 #include "disable_printer_query.h"
46 #include "disable_maintenance_mode_query.h"
47 #include "disable_mtp_client_query.h"
48 #include "disable_mtp_server_query.h"
49 #include "disable_samba_client_query.h"
50 #include "disable_samba_server_query.h"
51 #include "disable_set_biometrics_and_screenLock_query.h"
52 #include "disable_set_device_name_query.h"
53 #include "disable_user_mtp_client_query.h"
54 #include "disable_usb_query.h"
55 #include "disallow_add_local_account_query.h"
56 #include "disallow_export_recovery_key_query.h"
57 #include "disallow_distributed_transmission_query.h"
58 #include "disallow_modify_datetime_query.h"
59 #include "disallowed_airplane_mode_query.h"
60 #include "disallowed_bluetooth_devices_query.h"
61 #include "disallowed_install_bundles_query.h"
62 #include "disallowed_running_bundles_query.h"
63 #include "disallowed_tethering_query.h"
64 #include "disallowed_uninstall_bundles_query.h"
65 #include "disallowed_wifi_list_query.h"
66 #include "disallow_modify_apn_query.h"
67 #include "edm_constants.h"
68 #include "fingerprint_auth_query.h"
69 #include "get_device_encryption_status_query.h"
70 #include "get_display_version_query.h"
71 #include "get_security_patch_tag_query.h"
72 #include "is_app_kiosk_allowed_query.h"
73 #include "inactive_user_freeze_query.h"
74 #include "location_policy_query.h"
75 #include "ntp_server_query.h"
76 #include "parameters.h"
77 #include "password_policy.h"
78 #include "password_policy_query.h"
79 #include "password_policy_serializer.h"
80 #include "set_browser_policies_query.h"
81 #include "set_wifi_disabled_query.h"
82 #include "snapshot_skip_query.h"
83 #include "usb_read_only_query.h"
84 #include "disallowed_sms_query.h"
85 #include "disallowed_mms_query.h"
86 #ifndef FEATURE_PC_ONLY
87 #include "disallow_power_long_press_query.h"
88 #endif
89 #ifdef FEATURE_PC_ONLY
90 #include "get_auto_unlock_after_reboot_query.h"
91 #include "disable_usb_storage_device_write_query.h"
92 #include "disable_print_query.h"
93 #endif
94
95 #ifdef NETMANAGER_EXT_EDM_ENABLE
96 #include "disallow_vpn_query.h"
97 #endif
98
99 #ifdef SUDO_EDM_ENABLE
100 #include "disable_sudo_query.h"
101 #endif
102
103 #ifdef NOTIFICATION_EDM_ENABLE
104 #include "disallowed_notification_query.h"
105 #endif
106
107 using namespace testing::ext;
108 using namespace OHOS;
109 using namespace OHOS::EDM;
110
111 namespace OHOS {
112 namespace EDM {
113 namespace TEST {
114 class PluginPolicyQueryTest : public testing::Test {
115 protected:
116 void SetUp() override;
117
118 void TearDown() override;
119 };
120 const std::string POLICY_DATA = "[{\"tokenId\":1,\"userId\":100,\"bundleName\":\"com.ohos.test1\","
121 "\"clipboardPolicy\":1},{\"tokenId\":2,\"userId\":100,\"bundleName\":\"com.ohos.test2\",\"clipboardPolicy\":2}]";
122 const std::string TEST_VALUE_COMPLEXITYREG = "^(?=.*[a-zA-Z]).{1,9}$";
123 const int TEST_VALUE_VALIDITY_PERIOD = 2;
124 const std::string TEST_VALUE_ADDITIONAL_DESCRIPTION = "testDescription";
125 const std::string TEST_POLICY_DATA =
126 "{\"complexityReg\":\"^(?=.*[a-zA-Z]).{1,9}$\", \"validityPeriod\": 2,"
127 "\"additionalDescription\": \"testDescription\"}";
128 const std::string PERSIST_BLUETOOTH_CONTROL = "persist.edm.prohibit_bluetooth";
129 const std::string PERSIST_EDM_SET_BIOMETRICS_AND_SCREENLOCK_DISABLE =
130 "persist.edm.set_biometrics_and_screenLock_disable";
131 const std::string PERSIST_EDM_SET_DEVICE_NAME_DISABLE =
132 "persist.edm.set_device_name_disable";
133 const std::string TEST_PERMISSION_TAG_VERSION_11 = "version_11";
134 const std::string TEST_PERMISSION_TAG_VERSION_12 = "version_12";
135 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_BLUETOOTH = "ohos.permission.ENTERPRISE_MANAGE_BLUETOOTH";
136 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_USB = "ohos.permission.ENTERPRISE_MANAGE_USB";
137 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_SECURITY = "ohos.permission.ENTERPRISE_MANAGE_SECURITY";
138 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS = "ohos.permission.ENTERPRISE_MANAGE_RESTRICTIONS";
139 const std::string TEST_PERMISSION_PERSONAL_MANAGE_RESTRICTIONS = "ohos.permission.PERSONAL_MANAGE_RESTRICTIONS";
140 const std::string TEST_PERMISSION_ENTERPRISE_RESTRICT_POLICY = "ohos.permission.ENTERPRISE_RESTRICT_POLICY";
141 const std::string TEST_PERMISSION_ENTERPRISE_SET_ACCOUNT_POLICY = "ohos.permission.ENTERPRISE_SET_ACCOUNT_POLICY";
142 const std::string TEST_PERMISSION_ENTERPRISE_SET_DATETIME = "ohos.permission.ENTERPRISE_SET_DATETIME";
143 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_WIFI = "ohos.permission.ENTERPRISE_MANAGE_WIFI";
144 const std::string TEST_PERMISSION_ENTERPRISE_SET_BUNDLE_INSTALL_POLICY =
145 "ohos.permission.ENTERPRISE_SET_BUNDLE_INSTALL_POLICY";
146 const std::string TEST_PERMISSION_ENTERPRISE_GET_DEVICE_INFO = "ohos.permission.ENTERPRISE_GET_DEVICE_INFO";
147 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_NETWORK = "ohos.permission.ENTERPRISE_MANAGE_NETWORK";
148 const std::string TEST_PERMISSION_ENTERPRISE_MANAGE_SYSTEM = "ohos.permission.ENTERPRISE_MANAGE_SYSTEM";
149 const std::string TEST_PERMISSION_ENTERPRISE_SET_USER_RESTRICTION = "ohos.permission.ENTERPRISE_SET_USER_RESTRICTION";
SetUp()150 void PluginPolicyQueryTest::SetUp() {}
151
TearDown()152 void PluginPolicyQueryTest::TearDown() {}
153
154 /**
155 * @tc.name: TestAllowedBluetoothDevicesQuery
156 * @tc.desc: Test AllowedBluetoothDevicesQuery::QueryPolicy func.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(PluginPolicyQueryTest, TestAllowedBluetoothDevicesQuery, TestSize.Level1)
160 {
161 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedBluetoothDevicesQuery>();
162 std::string policyValue{"GetBluetoothDevices"};
163 MessageParcel data;
164 MessageParcel reply;
165 ErrCode ret = queryObj->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
166 int32_t flag = ERR_INVALID_VALUE;
167 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
168 ASSERT_TRUE(ret == ERR_OK);
169 }
170
171 /**
172 * @tc.name: TestAllowedBluetoothDevicesQuery001
173 * @tc.desc: Test AllowedBluetoothDevicesQuery GetPolicyName and GetPermission func.
174 * @tc.type: FUNC
175 */
176 HWTEST_F(PluginPolicyQueryTest, TestAllowedBluetoothDevicesQuery001, TestSize.Level1)
177 {
178 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedBluetoothDevicesQuery>();
179 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
180 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
181 == TEST_PERMISSION_ENTERPRISE_MANAGE_BLUETOOTH);
182 ASSERT_TRUE(queryObj->GetPolicyName() == "allowed_bluetooth_devices");
183 }
184
185 /**
186 * @tc.name: TestDisallowedBluetoothDevicesQuery
187 * @tc.desc: Test DisallowedBluetoothDevicesQuery::QueryPolicy func.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(PluginPolicyQueryTest, TestDisallowedBluetoothDevicesQuery, TestSize.Level1)
191 {
192 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedBluetoothDevicesQuery>();
193 std::string policyValue{"GetBluetoothDevices"};
194 MessageParcel data;
195 MessageParcel reply;
196 ErrCode ret = queryObj->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
197 int32_t flag = ERR_INVALID_VALUE;
198 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
199 ASSERT_TRUE(ret == ERR_OK);
200 }
201
202 /**
203 * @tc.name: TestDisallowedBluetoothDevicesQuery001
204 * @tc.desc: Test DisallowedBluetoothDevicesQuery GetPolicyName and GetPermission func.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(PluginPolicyQueryTest, TestDisallowedBluetoothDevicesQuery001, TestSize.Level1)
208 {
209 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedBluetoothDevicesQuery>();
210 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
211 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
212 == TEST_PERMISSION_ENTERPRISE_MANAGE_BLUETOOTH);
213 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_bluetooth_devices");
214 }
215
216 /**
217 * @tc.name: TestAllowedAppDistributionTypesQuery001
218 * @tc.desc: Test AllowedAppDistributionTypesQuery::QueryPolicy func.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(PluginPolicyQueryTest, TestAllowedAppDistributionTypesQuery001, TestSize.Level1)
222 {
223 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedAppDistributionTypesQuery>();
224 std::string policyValue{""};
225 MessageParcel data;
226 MessageParcel reply;
227 ErrCode ret = queryObj->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
228 int32_t flag = ERR_INVALID_VALUE;
229 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
230 ASSERT_TRUE(ret == ERR_OK);
231 }
232
233 /**
234 * @tc.name: TestAllowedAppDistributionTypesQuery002
235 * @tc.desc: Test AllowedAppDistributionTypesQuery GetPolicyName and GetPermission func.
236 * @tc.type: FUNC
237 */
238 HWTEST_F(PluginPolicyQueryTest, TestAllowedAppDistributionTypesQuery002, TestSize.Level1)
239 {
240 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedAppDistributionTypesQuery>();
241 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
242 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
243 == TEST_PERMISSION_ENTERPRISE_SET_BUNDLE_INSTALL_POLICY);
244 ASSERT_TRUE(queryObj->GetPolicyName() == "allowed_install_app_type");
245 }
246
247 /**
248 * @tc.name: TestAllowedUsbDevicesQuery
249 * @tc.desc: Test EnterpriseAdminConnection::OnAbilityConnectDone func.
250 * @tc.type: FUNC
251 */
252 HWTEST_F(PluginPolicyQueryTest, TestAllowedUsbDevicesQuery, TestSize.Level1)
253 {
254 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedUsbDevicesQuery>();
255 std::string policyData{""};
256 MessageParcel data;
257 MessageParcel reply;
258 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
259 int32_t flag = ERR_INVALID_VALUE;
260 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
261 ASSERT_TRUE(ret == ERR_OK);
262 }
263
264 /**
265 * @tc.name: TestAllowedUsbDevicesQuery001
266 * @tc.desc: Test AllowedUsbDevicesQuery GetPolicyName and GetPermission function.
267 * @tc.type: FUNC
268 */
269 HWTEST_F(PluginPolicyQueryTest, TestAllowedUsbDevicesQuery001, TestSize.Level1)
270 {
271 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedUsbDevicesQuery>();
272 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
273 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
274 == TEST_PERMISSION_ENTERPRISE_MANAGE_USB);
275 ASSERT_TRUE(queryObj->GetPolicyName() == "allowed_usb_devices");
276 }
277
278 /**
279 * @tc.name: TestAllowedWifiListQuery001
280 * @tc.desc: Test AllowedWifiListQuery::QueryPolicy
281 * @tc.type: FUNC
282 */
283 HWTEST_F(PluginPolicyQueryTest, TestAllowedWifiListQuery001, TestSize.Level1)
284 {
285 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedWifiListQuery>();
286 std::string policyData{""};
287 MessageParcel data;
288 MessageParcel reply;
289 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
290 int32_t flag = ERR_INVALID_VALUE;
291 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
292 ASSERT_TRUE(ret == ERR_OK);
293 }
294
295 /**
296 * @tc.name: TestAllowedWifiListQuery002
297 * @tc.desc: Test AllowedWifiListQuery::QueryPolicy
298 * @tc.type: FUNC
299 */
300 HWTEST_F(PluginPolicyQueryTest, TestAllowedWifiListQuery002, TestSize.Level1)
301 {
302 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedWifiListQuery>();
303 std::string policyData = R"({"key": "value"})";
304 MessageParcel data;
305 MessageParcel reply;
306 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
307 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
308 }
309
310 /**
311 * @tc.name: TestAllowedWifiListQuery003
312 * @tc.desc: Test Test AllowedWifiListQuery GetPolicyName and GetPermission function.
313 * @tc.type: FUNC
314 */
315 HWTEST_F(PluginPolicyQueryTest, TestAllowedWifiListQuery003, TestSize.Level1)
316 {
317 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedWifiListQuery>();
318 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
319 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
320 == TEST_PERMISSION_ENTERPRISE_MANAGE_WIFI);
321 ASSERT_TRUE(queryObj->GetPolicyName() == "allowed_wifi_list");
322 }
323
324 /**
325 * @tc.name: TestDisallowedWifiListQuery001
326 * @tc.desc: Test AllowedWifiListQuery::QueryPolicy
327 * @tc.type: FUNC
328 */
329 HWTEST_F(PluginPolicyQueryTest, TestDisallowedWifiListQuery001, TestSize.Level1)
330 {
331 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedWifiListQuery>();
332 std::string policyData{""};
333 MessageParcel data;
334 MessageParcel reply;
335 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
336 int32_t flag = ERR_INVALID_VALUE;
337 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
338 ASSERT_TRUE(ret == ERR_OK);
339 }
340
341 /**
342 * @tc.name: TestDisallowedWifiListQuery002
343 * @tc.desc: Test DisallowedWifiListQuery::QueryPolicy
344 * @tc.type: FUNC
345 */
346 HWTEST_F(PluginPolicyQueryTest, TestDisallowedWifiListQuery002, TestSize.Level1)
347 {
348 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedWifiListQuery>();
349 std::string policyData = R"({"key": "value"})";
350 MessageParcel data;
351 MessageParcel reply;
352 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
353 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
354 }
355
356 /**
357 * @tc.name: TestDisallowedWifiListQuery003
358 * @tc.desc: Test Test DisallowedWifiListQuery GetPolicyName and GetPermission function.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(PluginPolicyQueryTest, TestDisallowedWifiListQuery003, TestSize.Level1)
362 {
363 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedWifiListQuery>();
364 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
365 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
366 == TEST_PERMISSION_ENTERPRISE_MANAGE_WIFI);
367 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_wifi_list");
368 }
369
370 /**
371 * @tc.name: TestClipboardPolicyQuery
372 * @tc.desc: Test ClipboardPolicyQuery::QueryPolicy.
373 * @tc.type: FUNC
374 */
375 HWTEST_F(PluginPolicyQueryTest, TestClipboardPolicyQuery001, TestSize.Level1)
376 {
377 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<ClipboardPolicyQuery>();
378 MessageParcel data;
379 MessageParcel reply;
380 data.WriteInt32(5);
381 std::string policyData = POLICY_DATA;
382 queryObj->QueryPolicy(policyData, data, reply, 0);
383 int32_t ret = reply.ReadInt32();
384 std::string policy = reply.ReadString();
385 std::map<int32_t, ClipboardInfo> policyMap;
386 auto serializer = ClipboardSerializer::GetInstance();
387 serializer->Deserialize(policy, policyMap);
388 ASSERT_TRUE(ret == ERR_OK);
389 ASSERT_TRUE(policyMap.size() == 2);
390 }
391
392 /**
393 * @tc.name: TestClipboardPolicyQuery002
394 * @tc.desc: Test ClipboardPolicyPluginTest::QueryPolicy.
395 * @tc.type: FUNC
396 */
397 HWTEST_F(PluginPolicyQueryTest, TestClipboardPolicyQuery002, TestSize.Level1)
398 {
399 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<ClipboardPolicyQuery>();
400 MessageParcel data;
401 MessageParcel reply;
402 std::string policyData = POLICY_DATA;
403 data.WriteInt32(3);
404 data.WriteInt32(1);
405 queryObj->QueryPolicy(policyData, data, reply, 0);
406 int32_t ret = reply.ReadInt32();
407 std::string policy = reply.ReadString();
408 std::map<int32_t, ClipboardInfo> policyMap;
409 auto serializer = ClipboardSerializer::GetInstance();
410 serializer->Deserialize(policy, policyMap);
411 ASSERT_TRUE(ret == ERR_OK);
412 ASSERT_TRUE(policyMap[1].policy == ClipboardPolicy::IN_APP);
413 }
414
415 /**
416 * @tc.name: TestClipboardPolicyQuery003
417 * @tc.desc: Test ClipboardPolicyQuery GetPolicyName and GetPermission function.
418 * @tc.type: FUNC
419 */
420 HWTEST_F(PluginPolicyQueryTest, TestClipboardPolicyQuery003, TestSize.Level1)
421 {
422 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<ClipboardPolicyQuery>();
423 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
424 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
425 == TEST_PERMISSION_ENTERPRISE_MANAGE_SECURITY);
426 ASSERT_TRUE(queryObj->GetPolicyName() == "clipboard_policy");
427 }
428
429 /**
430 * @tc.name: TestDisableBluetoothQuery001
431 * @tc.desc: Test DisableBluetoothQuery::QueryPolicy function.
432 * @tc.type: FUNC
433 */
434 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery001, TestSize.Level1)
435 {
436 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBluetoothQuery>();
437 std::string policyData{"false"};
438 MessageParcel data;
439 MessageParcel reply;
440 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
441 ASSERT_TRUE(ret == ERR_OK);
442 int32_t flag = ERR_INVALID_VALUE;
443 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
444 ASSERT_EQ(OHOS::system::GetBoolParameter(PERSIST_BLUETOOTH_CONTROL, false),
445 reply.ReadBool());
446 }
447
448 /**
449 * @tc.name: TestDisableBluetoothQuery002
450 * @tc.desc: Test DisableBluetoothQuery::QueryPolicy function.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery002, TestSize.Level1)
454 {
455 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBluetoothQuery>();
456 std::string policyData{"false"};
457 MessageParcel data;
458 MessageParcel reply;
459 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
460 int32_t flag = ERR_INVALID_VALUE;
461 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
462 bool result = false;
463 reply.ReadBool(result);
464 ASSERT_TRUE(ret == ERR_OK);
465 }
466
467 /**
468 * @tc.name: TestDisableBluetoothQuery003
469 * @tc.desc: Test DisableBluetoothQuery GetPolicyName and GetPermission function.
470 * @tc.type: FUNC
471 */
472 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery003, TestSize.Level1)
473 {
474 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBluetoothQuery>();
475 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
476 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
477 == TEST_PERMISSION_ENTERPRISE_MANAGE_BLUETOOTH);
478
479 permissionTag = TEST_PERMISSION_TAG_VERSION_12;
480 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
481 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
482 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::BYOD_DEVICE_ADMIN, permissionTag)
483 == TEST_PERMISSION_PERSONAL_MANAGE_RESTRICTIONS);
484 ASSERT_TRUE(queryObj->GetPolicyName() == "disabled_bluetooth");
485 }
486
487 /**
488 * @tc.name: DisablePrinterQuery001
489 * @tc.desc: Test DisablePrinterPluginTest::QueryPolicy function.
490 * @tc.type: FUNC
491 */
492 HWTEST_F(PluginPolicyQueryTest, TestDisablePrinterQuery001, TestSize.Level1)
493 {
494 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisablePrinterQuery>();
495 std::string policyData{"false"};
496 MessageParcel data;
497 MessageParcel reply;
498 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
499 int32_t flag = ERR_INVALID_VALUE;
500 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
501 bool result = false;
502 reply.ReadBool(result);
503 ASSERT_TRUE(ret == ERR_OK);
504 ASSERT_FALSE(result);
505 }
506
507 /**
508 * @tc.name: TestDisablePrinterQuery002
509 * @tc.desc: Test DisablePrinterQuery GetPolicyName and GetPermission function.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(PluginPolicyQueryTest, TestDisablePrinterQuery002, TestSize.Level1)
513 {
514 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisablePrinterQuery>();
515 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
516 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
517 == TEST_PERMISSION_ENTERPRISE_RESTRICT_POLICY);
518
519 permissionTag = TEST_PERMISSION_TAG_VERSION_12;
520 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
521 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
522 ASSERT_TRUE(queryObj->GetPolicyName() == "disabled_printer");
523 }
524
525 /**
526 * @tc.name: DisableMtpClientQuery001
527 * @tc.desc: Test DisableMtpPluginTest::QueryPolicy function.
528 * @tc.type: FUNC
529 */
530 HWTEST_F(PluginPolicyQueryTest, TestDisableMtpClientQuery001, TestSize.Level1)
531 {
532 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableMtpClientQuery>();
533 std::string policyData{"false"};
534 MessageParcel data;
535 MessageParcel reply;
536 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
537 int32_t flag = ERR_INVALID_VALUE;
538 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
539 bool result = false;
540 reply.ReadBool(result);
541 ASSERT_TRUE(ret == ERR_OK);
542 ASSERT_FALSE(result);
543 }
544
545 /**
546 * @tc.name: TestDisableMtpClientQuery002
547 * @tc.desc: Test DisableMtpClientQuery GetPolicyName and GetPermission function.
548 * @tc.type: FUNC
549 */
550 HWTEST_F(PluginPolicyQueryTest, TestDisableMtpClientQuery002, TestSize.Level1)
551 {
552 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableMtpClientQuery>();
553 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
554 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
555 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
556 ASSERT_TRUE(queryObj->GetPolicyName() == "disabled_mtp_client");
557 }
558
559 /**
560 * @tc.name: DisableMtpServerQuery001
561 * @tc.desc: Test DisableMtpPluginTest::QueryPolicy function.
562 * @tc.type: FUNC
563 */
564 HWTEST_F(PluginPolicyQueryTest, TestDisableMtpServerQuery001, TestSize.Level1)
565 {
566 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableMtpServerQuery>();
567 std::string policyData{"false"};
568 MessageParcel data;
569 MessageParcel reply;
570 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
571 int32_t flag = ERR_INVALID_VALUE;
572 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
573 bool result = false;
574 reply.ReadBool(result);
575 ASSERT_TRUE(ret == ERR_OK);
576 ASSERT_FALSE(result);
577 }
578
579 /**
580 * @tc.name: TestDisableMtpServerQuery002
581 * @tc.desc: Test DisableMtpServerQuery GetPolicyName and GetPermission function.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(PluginPolicyQueryTest, TestDisableMtpServerQuery002, TestSize.Level1)
585 {
586 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableMtpServerQuery>();
587 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
588 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
589 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
590 ASSERT_TRUE(queryObj->GetPolicyName() == "disabled_mtp_server");
591 }
592
593 /**
594 * @tc.name: DisableUserMtpClientQuery001
595 * @tc.desc: Test DisableUserMtpPluginTest::QueryPolicy function.
596 * @tc.type: FUNC
597 */
598 HWTEST_F(PluginPolicyQueryTest, TestDisableUserMtpClientQuery001, TestSize.Level1)
599 {
600 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableUserMtpClientQuery>();
601 std::string policyData{"false"};
602 MessageParcel data;
603 MessageParcel reply;
604 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
605 int32_t flag = ERR_INVALID_VALUE;
606 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
607 bool result = false;
608 reply.ReadBool(result);
609 ASSERT_TRUE(ret == ERR_OK);
610 ASSERT_FALSE(result);
611 }
612
613 /**
614 * @tc.name: TestDisableUserMtpClientQuery002
615 * @tc.desc: Test DisableUserMtpClientQuery GetPolicyName and GetPermission function.
616 * @tc.type: FUNC
617 */
618 HWTEST_F(PluginPolicyQueryTest, TestDisableUserMtpClientQuery002, TestSize.Level1)
619 {
620 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableUserMtpClientQuery>();
621 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
622 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
623 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
624 ASSERT_TRUE(queryObj->GetPolicyName() == "disabled_user_mtp_client");
625 }
626
627 /**
628 * @tc.name: DisableSambaClientQuery001
629 * @tc.desc: Test DisableSambaPluginTest::QueryPolicy function.
630 * @tc.type: FUNC
631 */
632 HWTEST_F(PluginPolicyQueryTest, TestDisableSambaClientQuery001, TestSize.Level1)
633 {
634 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableSambaClientQuery>();
635 std::string policyData{"false"};
636 MessageParcel data;
637 MessageParcel reply;
638 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
639 int32_t flag = ERR_INVALID_VALUE;
640 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
641 bool result = false;
642 reply.ReadBool(result);
643 ASSERT_TRUE(ret == ERR_OK);
644 ASSERT_FALSE(result);
645 }
646
647 /**
648 * @tc.name: TestDisableSambaClientQuery002
649 * @tc.desc: Test DisableSambaClientQuery GetPolicyName and GetPermission function.
650 * @tc.type: FUNC
651 */
652 HWTEST_F(PluginPolicyQueryTest, TestDisableSambaClientQuery002, TestSize.Level1)
653 {
654 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableSambaClientQuery>();
655 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
656 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
657 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
658 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_DISABLED_SAMBA_CLIENT);
659 }
660
661 /**
662 * @tc.name: DisableSambaServerQuery001
663 * @tc.desc: Test DisableSambaPluginTest::QueryPolicy function.
664 * @tc.type: FUNC
665 */
666 HWTEST_F(PluginPolicyQueryTest, TestDisableSambaServerQuery001, TestSize.Level1)
667 {
668 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableSambaServerQuery>();
669 std::string policyData{"false"};
670 MessageParcel data;
671 MessageParcel reply;
672 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
673 int32_t flag = ERR_INVALID_VALUE;
674 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
675 bool result = false;
676 reply.ReadBool(result);
677 ASSERT_TRUE(ret == ERR_OK);
678 ASSERT_FALSE(result);
679 }
680
681 /**
682 * @tc.name: TestDisableSambaServerQuery002
683 * @tc.desc: Test DisableSambaServerQuery GetPolicyName and GetPermission function.
684 * @tc.type: FUNC
685 */
686 HWTEST_F(PluginPolicyQueryTest, TestDisableSambaServerQuery002, TestSize.Level1)
687 {
688 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableSambaServerQuery>();
689 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
690 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
691 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
692 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_DISABLED_SAMBA_SERVER);
693 }
694
695 /**
696 * @tc.name: DisableMaintenanceModeQuery001
697 * @tc.desc: Test DisableMtpPluginTest::QueryPolicy function.
698 * @tc.type: FUNC
699 */
700 HWTEST_F(PluginPolicyQueryTest, TestDisableMaintenanceModeQuery001, TestSize.Level1)
701 {
702 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableMaintenanceModeQuery>();
703 std::string policyData{"false"};
704 MessageParcel data;
705 MessageParcel reply;
706 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
707 int32_t flag = ERR_INVALID_VALUE;
708 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
709 bool result = false;
710 reply.ReadBool(result);
711 ASSERT_TRUE(ret == ERR_OK);
712 ASSERT_FALSE(result);
713 }
714
715 /**
716 * @tc.name: DisableMaintenanceModeQuery002
717 * @tc.desc: Test DisableMtpPluginTest::QueryPolicy function.
718 * @tc.type: FUNC
719 */
720 HWTEST_F(PluginPolicyQueryTest, TestDisableMaintenanceModeQuery002, TestSize.Level1)
721 {
722 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableMaintenanceModeQuery>();
723 std::string policyData{"true"};
724 MessageParcel data;
725 MessageParcel reply;
726 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
727 int32_t flag = ERR_INVALID_VALUE;
728 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
729 bool result = false;
730 reply.ReadBool(result);
731 ASSERT_TRUE(ret == ERR_OK);
732 ASSERT_TRUE(result);
733 }
734
735 /**
736 * @tc.name: TestDisableMaintenanceModeQuery003
737 * @tc.desc: Test DisableMaintenanceModeQuery GetPolicyName and GetPermission function.
738 * @tc.type: FUNC
739 */
740 HWTEST_F(PluginPolicyQueryTest, TestDisableMaintenanceModeQuery003, TestSize.Level1)
741 {
742 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableMaintenanceModeQuery>();
743 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
744 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
745 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
746 ASSERT_TRUE(queryObj->GetPolicyName() == "disabled_maintenance_mode");
747 }
748
749 /**
750 * @tc.name: TestDisableUsbQuery
751 * @tc.desc: Test DisableUsbQuery::QueryPolicy function.
752 * @tc.type: FUNC
753 */
754 HWTEST_F(PluginPolicyQueryTest, TestDisableUsbQuery, TestSize.Level1)
755 {
756 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableUsbQuery>();
757 std::string policyData{"false"};
758 MessageParcel data;
759 MessageParcel reply;
760 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
761 int32_t flag = ERR_INVALID_VALUE;
762 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
763 bool result = false;
764 reply.ReadBool(result);
765 ASSERT_TRUE(ret == ERR_OK);
766 ASSERT_FALSE(result);
767 }
768
769 /**
770 * @tc.name: TestDisableUsbQuery001
771 * @tc.desc: Test DisableUsbQuery GetPolicyName and GetPermission function.
772 * @tc.type: FUNC
773 */
774 HWTEST_F(PluginPolicyQueryTest, TestDisableUsbQuery001, TestSize.Level1)
775 {
776 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableUsbQuery>();
777 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
778 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
779 == TEST_PERMISSION_ENTERPRISE_MANAGE_USB);
780
781 permissionTag = TEST_PERMISSION_TAG_VERSION_12;
782 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
783 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
784 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::BYOD_DEVICE_ADMIN, permissionTag)
785 == TEST_PERMISSION_PERSONAL_MANAGE_RESTRICTIONS);
786 ASSERT_TRUE(queryObj->GetPolicyName() == "disable_usb");
787 }
788
789 /**
790 * @tc.name: TestDisallowAddLocalAccountQuery
791 * @tc.desc: Test DisallowAddLocalAccountQuery::QueryPolicy function.
792 * @tc.type: FUNC
793 */
794 HWTEST_F(PluginPolicyQueryTest, TestDisallowAddLocalAccountQuery, TestSize.Level1)
795 {
796 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisallowAddLocalAccountQuery>();
797 std::string policyData{"false"};
798 MessageParcel data;
799 MessageParcel reply;
800 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
801 int32_t flag = ERR_INVALID_VALUE;
802 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
803 bool result = false;
804 reply.ReadBool(result);
805 ASSERT_TRUE(ret == ERR_OK);
806 ASSERT_FALSE(result);
807 }
808
809 /**
810 * @tc.name: TestDisallowAddLocalAccountQuery001
811 * @tc.desc: Test DisallowAddLocalAccountQuery GetPolicyName and GetPermission function.
812 * @tc.type: FUNC
813 */
814 HWTEST_F(PluginPolicyQueryTest, TestDisallowAddLocalAccountQuery001, TestSize.Level1)
815 {
816 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowAddLocalAccountQuery>();
817 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
818 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
819 == TEST_PERMISSION_ENTERPRISE_SET_ACCOUNT_POLICY);
820 ASSERT_TRUE(queryObj->GetPolicyName() == "disallow_add_local_account");
821 }
822
823 /**
824 * @tc.name: TestDisallowModifyDateTimeQuery
825 * @tc.desc: Test TestDisallowModifyDateTimeQuery::QueryPolicy function.
826 * @tc.type: FUNC
827 */
828 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyDateTimeQuery, TestSize.Level1)
829 {
830 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisallowModifyDateTimeQuery>();
831 // origin policy is disallow to modify date time.
832 std::string policyData{"true"};
833 MessageParcel data;
834 MessageParcel reply;
835 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
836 int32_t flag = ERR_INVALID_VALUE;
837 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
838 bool result = false;
839 reply.ReadBool(result);
840 ASSERT_TRUE(ret == ERR_OK);
841 // get policy is disallow to modify date time.
842 ASSERT_TRUE(result);
843 }
844
845 /**
846 * @tc.name: TestDisallowModifyDateTimeQuery001
847 * @tc.desc: Test DisallowModifyDateTimeQuery GetPolicyName and GetPermission function.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyDateTimeQuery001, TestSize.Level1)
851 {
852 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowModifyDateTimeQuery>();
853 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
854 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
855 == TEST_PERMISSION_ENTERPRISE_SET_DATETIME);
856
857 permissionTag = TEST_PERMISSION_TAG_VERSION_12;
858 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
859 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
860 ASSERT_TRUE(queryObj->GetPolicyName() == "disallow_modify_datetime");
861 }
862
863 /**
864 * @tc.name: TestFingerprintAuthQuery001
865 * @tc.desc: Test FingerprintAuthQuery::QueryPolicy function.
866 * @tc.type: FUNC
867 */
868 HWTEST_F(PluginPolicyQueryTest, TestFingerprintAuthQuery001, TestSize.Level1)
869 {
870 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<FingerprintAuthQuery>();
871 MessageParcel data;
872 data.WriteString(EdmConstants::FINGERPRINT_AUTH_TYPE);
873 MessageParcel reply;
874 std::string policyData = "true";
875 plugin->QueryPolicy(policyData, data, reply, 100);
876 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
877 ASSERT_TRUE(reply.ReadBool());
878 }
879
880 /**
881 * @tc.name: TestFingerprintAuthQuery002
882 * @tc.desc: Test FingerprintAuthQuery::QueryPolicy function.
883 * @tc.type: FUNC
884 */
885 HWTEST_F(PluginPolicyQueryTest, TestFingerprintAuthQuery002, TestSize.Level1)
886 {
887 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<FingerprintAuthQuery>();
888 MessageParcel data;
889 data.WriteString(EdmConstants::DISALLOW_FOR_ACCOUNT_TYPE);
890 data.WriteInt32(100);
891 MessageParcel reply;
892 std::string policyData = "[100]";
893 plugin->QueryPolicy(policyData, data, reply, 100);
894 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
895 ASSERT_TRUE(reply.ReadBool());
896 }
897
898 /**
899 * @tc.name: TestFingerprintAuthQuery003
900 * @tc.desc: Test FingerprintAuthQuery GetPolicyName and GetPermission function.
901 * @tc.type: FUNC
902 */
903 HWTEST_F(PluginPolicyQueryTest, TestFingerprintAuthQuery003, TestSize.Level1)
904 {
905 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<FingerprintAuthQuery>();
906 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
907 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
908 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
909 ASSERT_TRUE(queryObj->GetPolicyName() == "fingerprint_auth");
910 }
911
912 /**
913 * @tc.name: TestGetDeviceEncryptionStatusQuery
914 * @tc.desc: Test get device encryption status function.
915 * @tc.type: FUNC
916 */
917 HWTEST_F(PluginPolicyQueryTest, TestGetDeviceEncryptionStatusQuery, TestSize.Level1)
918 {
919 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<GetDeviceEncryptionStatusQuery>();
920 std::string policyValue{"GetDeviceEncryptionStatus"};
921 MessageParcel data;
922 MessageParcel reply;
923 plugin->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
924 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
925 ASSERT_TRUE(reply.ReadBool() == true);
926 }
927
928 /**
929 * @tc.name: TestGetDeviceEncryptionStatusQuery001
930 * @tc.desc: Test GetDeviceEncryptionStatusQuery GetPolicyName and GetPermission function.
931 * @tc.type: FUNC
932 */
933 HWTEST_F(PluginPolicyQueryTest, TestGetDeviceEncryptionStatusQuery001, TestSize.Level1)
934 {
935 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetDeviceEncryptionStatusQuery>();
936 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
937 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
938 == TEST_PERMISSION_ENTERPRISE_MANAGE_SECURITY);
939 ASSERT_TRUE(queryObj->GetPolicyName() == "get_device_encryption_status");
940 }
941
942 /**
943 * @tc.name: TestGetSecurityPatchTagSuc
944 * @tc.desc: Test get security patch tag function.
945 * @tc.type: FUNC
946 */
947 HWTEST_F(PluginPolicyQueryTest, TestGetSecurityPatchTagSuc, TestSize.Level1)
948 {
949 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<GetSecurityPatchTagQuery>();
950 std::string policyValue{"GetSecurityPatchTag"};
951 MessageParcel data;
952 MessageParcel reply;
953 plugin->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
954 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
955 ASSERT_TRUE(reply.ReadString() != "");
956 }
957
958 /**
959 * @tc.name: TestGetSecurityPatchTagQuery001
960 * @tc.desc: Test GetSecurityPatchTagQuery GetPolicyName and GetPermission function.
961 * @tc.type: FUNC
962 */
963 HWTEST_F(PluginPolicyQueryTest, TestGetSecurityPatchTagQuery001, TestSize.Level1)
964 {
965 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetSecurityPatchTagQuery>();
966 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
967 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
968 == TEST_PERMISSION_ENTERPRISE_MANAGE_SECURITY);
969 ASSERT_TRUE(queryObj->GetPolicyName() == "get_security_patch_tag");
970 }
971
972 /**
973 * @tc.name: TestUsbReadOnlyQuery001
974 * @tc.desc: Test UsbReadOnlyQuery::QueryPolicy function when policy is read only.
975 * @tc.type: FUNC
976 */
977 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery001, TestSize.Level1)
978 {
979 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<UsbReadOnlyQuery>();
980 MessageParcel data;
981 MessageParcel reply;
982 std::string policyData{"1"};
983 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
984 ASSERT_TRUE(ret == ERR_OK);
985 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
986 ASSERT_TRUE(reply.ReadInt32() == 1);
987 }
988
989 /**
990 * @tc.name: TestUsbReadOnlyQuery002
991 * @tc.desc: Test UsbReadOnlyQuery::QueryPolicy function when policy is disabled.
992 * @tc.type: FUNC
993 */
994 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery002, TestSize.Level1)
995 {
996 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<UsbReadOnlyQuery>();
997 MessageParcel data;
998 MessageParcel reply;
999 std::string policyData{"2"};
1000 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1001 ASSERT_TRUE(ret == ERR_OK);
1002 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
1003 ASSERT_TRUE(reply.ReadInt32() == 2);
1004 }
1005
1006 /**
1007 * @tc.name: TestUsbReadOnlyQuery003
1008 * @tc.desc: Test UsbReadOnlyQuery::QueryPolicy function when policy is empty.
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery003, TestSize.Level1)
1012 {
1013 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<UsbReadOnlyQuery>();
1014 MessageParcel data;
1015 MessageParcel reply;
1016 std::string policyData{""};
1017 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1018 ASSERT_TRUE(ret == ERR_OK);
1019 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
1020 ASSERT_TRUE(reply.ReadInt32() == 0);
1021 }
1022
1023 /**
1024 * @tc.name: TestUsbReadOnlyQuery004
1025 * @tc.desc: Test UsbReadOnlyQuery GetPolicyName and GetPermission function.
1026 * @tc.type: FUNC
1027 */
1028 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery004, TestSize.Level1)
1029 {
1030 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<UsbReadOnlyQuery>();
1031 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1032 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1033 == TEST_PERMISSION_ENTERPRISE_MANAGE_USB);
1034 ASSERT_TRUE(queryObj->GetPolicyName() == "usb_read_only");
1035 }
1036
1037 /**
1038 * @tc.name: TestSetWifiDisabledQuery
1039 * @tc.desc: Test SetWifiDisabledQuery::QueryPolicy function.
1040 * @tc.type: FUNC
1041 */
1042 HWTEST_F(PluginPolicyQueryTest, TestSetWifiDisabledQuery, TestSize.Level1)
1043 {
1044 const std::string KEY_DISABLE_WIFI = "persist.edm.wifi_enable";
1045 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<SetWifiDisabledQuery>();
1046 std::string policyData{"false"};
1047 MessageParcel data;
1048 MessageParcel reply;
1049 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1050 int32_t flag = ERR_INVALID_VALUE;
1051 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1052 bool result = false;
1053 reply.ReadBool(result);
1054 ASSERT_TRUE(ret == ERR_OK);
1055 ASSERT_TRUE(result == system::GetBoolParameter(KEY_DISABLE_WIFI, false));
1056 }
1057
1058 /**
1059 * @tc.name: TestSetWifiDisabledQuery001
1060 * @tc.desc: Test SetWifiDisabledQuery GetPolicyName and GetPermission function.
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(PluginPolicyQueryTest, TestSetWifiDisabledQuery001, TestSize.Level1)
1064 {
1065 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<SetWifiDisabledQuery>();
1066 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1067 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1068 == TEST_PERMISSION_ENTERPRISE_MANAGE_WIFI);
1069
1070 permissionTag = TEST_PERMISSION_TAG_VERSION_12;
1071 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1072 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1073 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::BYOD_DEVICE_ADMIN, permissionTag)
1074 == TEST_PERMISSION_PERSONAL_MANAGE_RESTRICTIONS);
1075 ASSERT_TRUE(queryObj->GetPolicyName() == "disable_wifi");
1076 }
1077
1078 /**
1079 * @tc.name: TestDisableBluetoothQuery
1080 * @tc.desc: Test DisableBluetoothPluginTest::QueryPolicy function.
1081 * @tc.type: FUNC
1082 */
1083 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery, TestSize.Level1)
1084 {
1085 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableBluetoothQuery>();
1086 std::string policyData{"false"};
1087 MessageParcel data;
1088 MessageParcel reply;
1089 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1090 ASSERT_TRUE(ret == ERR_OK);
1091 int32_t flag = ERR_INVALID_VALUE;
1092 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1093 ASSERT_EQ(OHOS::system::GetBoolParameter(PERSIST_BLUETOOTH_CONTROL, false),
1094 reply.ReadBool());
1095 }
1096
1097 /**
1098 * @tc.name: TestPasswordPolicyQuery
1099 * @tc.desc: Test PasswordPolicyQuery::QueryPolicy when policyData is empty
1100 * and policies is empty.
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery, TestSize.Level1)
1104 {
1105 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<PasswordPolicyQuery>();
1106 MessageParcel data;
1107 MessageParcel reply;
1108 std::string policyData;
1109 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, 0);
1110 ASSERT_TRUE(ret == ERR_OK);
1111 ASSERT_TRUE(policyData.empty());
1112 }
1113
1114 /**
1115 * @tc.name: TestPasswordPolicyQuery002
1116 * @tc.desc: Test PasswordPolicyQuery::QueryPolicy when policyData is err
1117 * and policies is err.
1118 * @tc.type: FUNC
1119 */
1120 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery002, TestSize.Level1)
1121 {
1122 const std::string TEST_POLICY_ERR_DATA =
1123 "{\"comple\":\"^(?=.*[a-zA-Z]).{1,9}$\", \"validityPeriod\": 2,"
1124 "\"additionalDescription\": \"testDescription\"}";
1125 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<PasswordPolicyQuery>();
1126 MessageParcel data;
1127 MessageParcel reply;
1128 std::string policyData = TEST_POLICY_ERR_DATA;
1129 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, 0);
1130 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
1131 }
1132
1133 /**
1134 * @tc.name: TestPasswordPolicyQuery003
1135 * @tc.desc: Test PasswordPolicyQuery::QueryPolicy
1136 * and policies is empty.
1137 * @tc.type: FUNC
1138 */
1139 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery003, TestSize.Level1)
1140 {
1141 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<PasswordPolicyQuery>();
1142 MessageParcel data;
1143 MessageParcel reply;
1144 std::string policyData = TEST_POLICY_DATA;
1145 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, 0);
1146 ASSERT_TRUE(ret == ERR_OK);
1147 auto serializer_ = PasswordSerializer::GetInstance();
1148 PasswordPolicy policy;
1149 serializer_->Deserialize(policyData, policy);
1150 ASSERT_TRUE(policy.additionalDescription == TEST_VALUE_ADDITIONAL_DESCRIPTION);
1151 ASSERT_TRUE(policy.validityPeriod == TEST_VALUE_VALIDITY_PERIOD);
1152 ASSERT_TRUE(policy.complexityReg == TEST_VALUE_COMPLEXITYREG);
1153 }
1154
1155 /**
1156 * @tc.name: TestPasswordPolicyQuery004
1157 * @tc.desc: Test PasswordPolicyQuery GetPolicyName and GetPermission function.
1158 * @tc.type: FUNC
1159 */
1160 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery004, TestSize.Level1)
1161 {
1162 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<PasswordPolicyQuery>();
1163 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1164 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1165 == TEST_PERMISSION_ENTERPRISE_MANAGE_SECURITY);
1166 ASSERT_TRUE(queryObj->GetPolicyName() == "password_policy");
1167 }
1168
1169 /**
1170 * @tc.name: TestSetBrowserPoliciesQuery
1171 * @tc.desc: Test SetBrowserPoliciesQuery::QueryPolicy.
1172 * @tc.type: FUNC
1173 */
1174 HWTEST_F(PluginPolicyQueryTest, TestSetBrowserPoliciesQuery, TestSize.Level1)
1175 {
1176 const std::string TestAppId = "test_app_id";
1177 const std::string TestPolicyData = "{\"test_app_id\": {\"test_policy_name\":\"test_policy_value\"}}";
1178 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<SetBrowserPoliciesQuery>();
1179 MessageParcel data;
1180 MessageParcel reply;
1181 data.WriteString(TestAppId);
1182 std::string policyData = TestPolicyData;
1183 plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1184 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
1185 auto serializer = CjsonSerializer::GetInstance();
1186 cJSON* root = nullptr;
1187 serializer->Deserialize(TestPolicyData, root);
1188 cJSON* policy = cJSON_GetObjectItem(root, TestAppId.c_str());
1189 std::string retString;
1190 serializer->Serialize(policy, retString);
1191 ASSERT_TRUE(reply.ReadString() == retString);
1192 }
1193
1194 /**
1195 * @tc.name: TestDisallowedInstallBundlesQuery001
1196 * @tc.desc: Test DisallowedInstallBundlesQuery QueryPolicy function.
1197 * @tc.type: FUNC
1198 */
1199 HWTEST_F(PluginPolicyQueryTest, TestDisallowedInstallBundlesQuery001, TestSize.Level1)
1200 {
1201 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedInstallBundlesQuery>();
1202 std::string policyData{"false"};
1203 MessageParcel data;
1204 MessageParcel reply;
1205 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1206 int32_t flag = ERR_INVALID_VALUE;
1207 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1208 bool result = false;
1209 reply.ReadBool(result);
1210 ASSERT_TRUE(ret == ERR_OK);
1211 }
1212
1213 /**
1214 * @tc.name: TestDisallowedInstallBundlesQuery002
1215 * @tc.desc: Test DisallowedInstallBundlesQuery GetPolicyName and GetPermission function.
1216 * @tc.type: FUNC
1217 */
1218 HWTEST_F(PluginPolicyQueryTest, TestDisallowedInstallBundlesQuery002, TestSize.Level1)
1219 {
1220 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedInstallBundlesQuery>();
1221 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1222 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1223 == TEST_PERMISSION_ENTERPRISE_SET_BUNDLE_INSTALL_POLICY);
1224 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_install_bundles");
1225 }
1226
1227 /**
1228 * @tc.name: TestDisallowedThtheringQuery001
1229 * @tc.desc: Test DisallowedThtheringQuery QueryPolicy function.
1230 * @tc.type: FUNC
1231 */
1232 HWTEST_F(PluginPolicyQueryTest, TestDisallowedThtheringQuery001, TestSize.Level1)
1233 {
1234 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedThtheringQuery>();
1235 std::string policyData{"false"};
1236 MessageParcel data;
1237 MessageParcel reply;
1238 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1239 int32_t flag = ERR_INVALID_VALUE;
1240 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1241 bool result = false;
1242 reply.ReadBool(result);
1243 ASSERT_TRUE(ret == ERR_OK);
1244 }
1245
1246 /**
1247 * @tc.name: TestDisallowedThtheringQuery002
1248 * @tc.desc: Test DisallowedThtheringQuery GetPolicyName and GetPermission function.
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(PluginPolicyQueryTest, TestDisallowedThtheringQuery002, TestSize.Level1)
1252 {
1253 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedThtheringQuery>();
1254 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1255 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1256 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1257 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::BYOD_DEVICE_ADMIN, permissionTag)
1258 == TEST_PERMISSION_PERSONAL_MANAGE_RESTRICTIONS);
1259 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_tethering");
1260 }
1261
1262 /**
1263 * @tc.name: TestDisallowedUninstallBundlesQuery001
1264 * @tc.desc: Test DisallowedUninstallBundlesQuery QueryPolicy function.
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(PluginPolicyQueryTest, TestDisallowedUninstallBundlesQuery001, TestSize.Level1)
1268 {
1269 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedUninstallBundlesQuery>();
1270 std::string policyData{"false"};
1271 MessageParcel data;
1272 MessageParcel reply;
1273 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1274 int32_t flag = ERR_INVALID_VALUE;
1275 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1276 bool result = false;
1277 reply.ReadBool(result);
1278 ASSERT_TRUE(ret == ERR_OK);
1279 }
1280
1281 /**
1282 * @tc.name: TestDisallowedUninstallBundlesQuery002
1283 * @tc.desc: Test DisallowedUninstallBundlesQuery GetPolicyName and GetPermission function.
1284 * @tc.type: FUNC
1285 */
1286 HWTEST_F(PluginPolicyQueryTest, TestDisallowedUninstallBundlesQuery002, TestSize.Level1)
1287 {
1288 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedUninstallBundlesQuery>();
1289 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1290 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1291 == TEST_PERMISSION_ENTERPRISE_SET_BUNDLE_INSTALL_POLICY);
1292 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_uninstall_bundles");
1293 }
1294
1295 /**
1296 * @tc.name: TestGetDisplayVersionQuery001
1297 * @tc.desc: Test GetDisplayVersionQuery QueryPolicy function.
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(PluginPolicyQueryTest, TestGetDisplayVersionQuery001, TestSize.Level1)
1301 {
1302 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetDisplayVersionQuery>();
1303 std::string policyData{"false"};
1304 MessageParcel data;
1305 MessageParcel reply;
1306 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1307 int32_t flag = ERR_INVALID_VALUE;
1308 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1309 bool result = false;
1310 reply.ReadBool(result);
1311 ASSERT_TRUE(ret == ERR_OK);
1312 }
1313
1314 /**
1315 * @tc.name: TestGetDisplayVersionQuery002
1316 * @tc.desc: Test GetDisplayVersionQuery GetPolicyName and GetPermission function.
1317 * @tc.type: FUNC
1318 */
1319 HWTEST_F(PluginPolicyQueryTest, TestGetDisplayVersionQuery002, TestSize.Level1)
1320 {
1321 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetDisplayVersionQuery>();
1322 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1323 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1324 == TEST_PERMISSION_ENTERPRISE_GET_DEVICE_INFO);
1325 ASSERT_TRUE(queryObj->GetPolicyName() == "get_display_version");
1326 ASSERT_TRUE(queryObj->GetApiType() == IPlugin::ApiType::SYSTEM);
1327 }
1328
1329 /**
1330 * @tc.name: TestInactiveUserFreezeQuery001
1331 * @tc.desc: Test InactiveUserFreezeQuery QueryPolicy function.
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(PluginPolicyQueryTest, TestInactiveUserFreezeQuery001, TestSize.Level1)
1335 {
1336 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<InactiveUserFreezeQuery>();
1337 std::string policyData{"false"};
1338 MessageParcel data;
1339 MessageParcel reply;
1340 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1341 int32_t flag = ERR_INVALID_VALUE;
1342 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1343 bool result = false;
1344 reply.ReadBool(result);
1345 ASSERT_TRUE(ret == ERR_OK);
1346 }
1347
1348 /**
1349 * @tc.name: TestInactiveUserFreezeQuery002
1350 * @tc.desc: Test InactiveUserFreezeQuery GetPolicyName and GetPermission function.
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(PluginPolicyQueryTest, TestInactiveUserFreezeQuery002, TestSize.Level1)
1354 {
1355 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<InactiveUserFreezeQuery>();
1356 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1357 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1358 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1359 ASSERT_TRUE(queryObj->GetPolicyName() == "inactive_user_freeze");
1360 }
1361
1362 /**
1363 * @tc.name: TestNTPServerQuery001
1364 * @tc.desc: Test NTPServerQuery QueryPolicy function.
1365 * @tc.type: FUNC
1366 */
1367 HWTEST_F(PluginPolicyQueryTest, TestNTPServerQuery001, TestSize.Level1)
1368 {
1369 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<NTPServerQuery>();
1370 std::string policyData{"false"};
1371 MessageParcel data;
1372 MessageParcel reply;
1373 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1374 int32_t flag = ERR_INVALID_VALUE;
1375 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1376 bool result = false;
1377 reply.ReadBool(result);
1378 ASSERT_TRUE(ret == ERR_OK);
1379 }
1380
1381 /**
1382 * @tc.name: TestNTPServerQuery002
1383 * @tc.desc: Test NTPServerQuery GetPolicyName and GetPermission function.
1384 * @tc.type: FUNC
1385 */
1386 HWTEST_F(PluginPolicyQueryTest, TestNTPServerQuery002, TestSize.Level1)
1387 {
1388 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<NTPServerQuery>();
1389 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1390 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1391 == TEST_PERMISSION_ENTERPRISE_MANAGE_SYSTEM);
1392 ASSERT_TRUE(queryObj->GetPolicyName() == "ntp_server");
1393 }
1394
1395 /**
1396 * @tc.name: TestSnapshotSkipQuery001
1397 * @tc.desc: Test SnapshotSkipQuery QueryPolicy function.
1398 * @tc.type: FUNC
1399 */
1400 HWTEST_F(PluginPolicyQueryTest, TestSnapshotSkipQuery001, TestSize.Level1)
1401 {
1402 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<SnapshotSkipQuery>();
1403 std::string policyData{"false"};
1404 MessageParcel data;
1405 MessageParcel reply;
1406 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1407 int32_t flag = ERR_INVALID_VALUE;
1408 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1409 bool result = false;
1410 reply.ReadBool(result);
1411 ASSERT_TRUE(ret == ERR_OK);
1412 }
1413
1414 /**
1415 * @tc.name: TestSnapshotSkipQuery002
1416 * @tc.desc: Test SnapshotSkipQuery GetPolicyName and GetPermission function.
1417 * @tc.type: FUNC
1418 */
1419 HWTEST_F(PluginPolicyQueryTest, TestSnapshotSkipQuery002, TestSize.Level1)
1420 {
1421 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<SnapshotSkipQuery>();
1422 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1423 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1424 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1425 ASSERT_TRUE(queryObj->GetPolicyName() == "snapshot_skip");
1426 }
1427
1428 /**
1429 * @tc.name: TestDisallowedSMSQuery001
1430 * @tc.desc: Test DisallowedSMSQuery QueryPolicy function.
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(PluginPolicyQueryTest, TestDisallowedSMSQuery001, TestSize.Level1)
1434 {
1435 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedSMSQuery>();
1436 std::string policyData{"false"};
1437 MessageParcel data;
1438 MessageParcel reply;
1439 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1440 int32_t flag = ERR_INVALID_VALUE;
1441 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1442 bool result = false;
1443 reply.ReadBool(result);
1444 ASSERT_TRUE(ret == ERR_OK);
1445 }
1446
1447 /**
1448 * @tc.name: TestDisallowedSMSQuery002
1449 * @tc.desc: Test DisallowedSMSQuery GetPolicyName and GetPermission function.
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(PluginPolicyQueryTest, TestDisallowedSMSQuery002, TestSize.Level1)
1453 {
1454 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedSMSQuery>();
1455 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1456 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1457 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1458 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_sms");
1459 }
1460
1461 /**
1462 * @tc.name: TestDisallowModifyAPNQuery001
1463 * @tc.desc: Test DisallowModifyAPNQuery QueryPolicy function.
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyAPNQuery001, TestSize.Level1)
1467 {
1468 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowModifyAPNQuery>();
1469 std::string policyData{"false"};
1470 MessageParcel data;
1471 MessageParcel reply;
1472 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1473 int32_t flag = ERR_INVALID_VALUE;
1474 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1475 bool result = false;
1476 reply.ReadBool(result);
1477 ASSERT_TRUE(ret == ERR_OK);
1478 }
1479
1480 /**
1481 * @tc.name: TestDisallowModifyAPNQuery002
1482 * @tc.desc: Test DisallowModifyAPNQuery GetPolicyName and GetPermission function.
1483 * @tc.type: FUNC
1484 */
1485 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyAPNQuery002, TestSize.Level1)
1486 {
1487 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowModifyAPNQuery>();
1488 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1489 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1490 == TEST_PERMISSION_ENTERPRISE_SET_USER_RESTRICTION);
1491 ASSERT_TRUE(queryObj->GetPolicyName() == "disallow_modify_apn");
1492 }
1493 /**
1494 * @tc.name: TestDisallowedMMSQuery001
1495 * @tc.desc: Test DisallowedMMSQuery QueryPolicy function.
1496 * @tc.type: FUNC
1497 */
1498 HWTEST_F(PluginPolicyQueryTest, TestDisallowedMMSQuery001, TestSize.Level1)
1499 {
1500 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedMMSQuery>();
1501 std::string policyData{"false"};
1502 MessageParcel data;
1503 MessageParcel reply;
1504 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1505 int32_t flag = ERR_INVALID_VALUE;
1506 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1507 bool result = false;
1508 reply.ReadBool(result);
1509 ASSERT_TRUE(ret == ERR_OK);
1510 }
1511
1512 /**
1513 * @tc.name: TestDisallowedMMSQuery002
1514 * @tc.desc: Test DisallowedMMSQuery GetPolicyName and GetPermission function.
1515 * @tc.type: FUNC
1516 */
1517 HWTEST_F(PluginPolicyQueryTest, TestDisallowedMMSQuery002, TestSize.Level1)
1518 {
1519 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedMMSQuery>();
1520 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1521 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1522 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1523 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_mms");
1524 }
1525
1526 #ifdef BACKUP_AND_RESTORE_EDM_ENABLE
1527 /**
1528 * @tc.name: TestDisableBackupAndRestoreQuery001
1529 * @tc.desc: Test DisableBackupAndRestoreQuery QueryPolicy function.
1530 * @tc.type: FUNC
1531 */
1532 HWTEST_F(PluginPolicyQueryTest, TestDisableBackupAndRestoreQuery001, TestSize.Level1)
1533 {
1534 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBackupAndRestoreQuery>();
1535 std::string policyData{"false"};
1536 MessageParcel data;
1537 MessageParcel reply;
1538 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1539 int32_t flag = ERR_INVALID_VALUE;
1540 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1541 bool result = false;
1542 reply.ReadBool(result);
1543 ASSERT_TRUE(ret == ERR_OK);
1544 }
1545
1546 /**
1547 * @tc.name: TestDisableBackupAndRestoreQuery002
1548 * @tc.desc: Test DisableBackupAndRestoreQuery GetPolicyName and GetPermission function.
1549 * @tc.type: FUNC
1550 */
1551 HWTEST_F(PluginPolicyQueryTest, TestDisableBackupAndRestoreQuery002, TestSize.Level1)
1552 {
1553 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBackupAndRestoreQuery>();
1554 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1555 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1556 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1557 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_DISABLE_BACKUP_AND_RESTORE);
1558 }
1559 #endif
1560
1561 /**
1562 * @tc.name: TestIsAppKioskAllowedQuery001
1563 * @tc.desc: Test IsAppKioskAllowedQuery GetPolicyName and GetPermission function.
1564 * @tc.type: FUNC
1565 */
1566 HWTEST_F(PluginPolicyQueryTest, TestIsAppKioskAllowedQuery001, TestSize.Level1)
1567 {
1568 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<IsAppKioskAllowedQuery>();
1569 std::string permissionTag;
1570 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag) == "");
1571 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_ALLOWED_KIOSK_APPS);
1572 }
1573
1574 /**
1575 * @tc.name: TestIsAppKioskAllowedQuery002
1576 * @tc.desc: Test IsAppKioskAllowedQuery QueryPolicy function.
1577 * @tc.type: FUNC
1578 */
1579 HWTEST_F(PluginPolicyQueryTest, TestIsAppKioskAllowedQuery002, TestSize.Level1)
1580 {
1581 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<IsAppKioskAllowedQuery>();
1582 std::string policyData{"[\"com.example.edmtest\"]"};
1583 MessageParcel data;
1584 data.WriteString("com.example.edmtest");
1585 MessageParcel reply;
1586 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1587 ASSERT_TRUE(ret == ERR_OK);
1588 int32_t flag = ERR_INVALID_VALUE;
1589 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1590 bool result = false;
1591 reply.ReadBool(result);
1592 ASSERT_TRUE(result);
1593 }
1594
1595 #ifndef FEATURE_PC_ONLY
1596 /**
1597 * @tc.name: TestDisallowPowerLongPressQuery001
1598 * @tc.desc: Test DisallowPowerLongPressQuery QueryPolicy function.
1599 * @tc.type: FUNC
1600 */
1601 HWTEST_F(PluginPolicyQueryTest, TestDisallowPowerLongPressQuery001, TestSize.Level1)
1602 {
1603 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowPowerLongPressQuery>();
1604 std::string policyData{"false"};
1605 MessageParcel data;
1606 MessageParcel reply;
1607 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1608 int32_t flag = ERR_INVALID_VALUE;
1609 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1610 bool result = false;
1611 reply.ReadBool(result);
1612 ASSERT_TRUE(ret == ERR_OK);
1613 }
1614
1615 /**
1616 * @tc.name: TestDisallowPowerLongPressQuery002
1617 * @tc.desc: Test DisallowPowerLongPressQuery GetPolicyName and GetPermission function.
1618 * @tc.type: FUNC
1619 */
1620 HWTEST_F(PluginPolicyQueryTest, TestDisallowPowerLongPressQuery002, TestSize.Level1)
1621 {
1622 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowPowerLongPressQuery>();
1623 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1624 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1625 == TEST_PERMISSION_ENTERPRISE_SET_USER_RESTRICTION);
1626 ASSERT_TRUE(queryObj->GetPolicyName() == "disallow_power_long_press");
1627 }
1628 #endif
1629
1630 /**
1631 * @tc.name: TestDisallowedAirplaneModeQuery001
1632 * @tc.desc: Test DisallowedAirplaneModeQuery QueryPolicy function.
1633 * @tc.type: FUNC
1634 */
1635 HWTEST_F(PluginPolicyQueryTest, TestDisallowedAirplaneModeQuery001, TestSize.Level1)
1636 {
1637 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedAirplaneModeQuery>();
1638 std::string policyData{"false"};
1639 MessageParcel data;
1640 MessageParcel reply;
1641 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1642 int32_t flag = ERR_INVALID_VALUE;
1643 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1644 bool result = false;
1645 reply.ReadBool(result);
1646 ASSERT_TRUE(ret == ERR_OK);
1647 }
1648
1649 /**
1650 * @tc.name: TestDisallowedAirplaneModeQuery002
1651 * @tc.desc: Test DisallowedAirplaneModeQuery GetPolicyName and GetPermission function.
1652 * @tc.type: FUNC
1653 */
1654 HWTEST_F(PluginPolicyQueryTest, TestDisallowedAirplaneModeQuery002, TestSize.Level1)
1655 {
1656 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedAirplaneModeQuery>();
1657 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1658 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1659 == TEST_PERMISSION_ENTERPRISE_MANAGE_NETWORK);
1660 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_airplane_mode");
1661 }
1662
1663 /**
1664 * @tc.name: TestDisableSetBiometricsAndScreenLockQuery001
1665 * @tc.desc: Test DisableSetBiometricsAndScreenLockQuery::QueryPolicy function.
1666 * @tc.type: FUNC
1667 */
1668 HWTEST_F(PluginPolicyQueryTest, TestDisableSetBiometricsAndScreenLockQuery001, TestSize.Level1)
1669 {
1670 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableSetBiometricsAndScreenLockQuery>();
1671 std::string policyData("false");
1672 MessageParcel data;
1673 MessageParcel reply;
1674 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1675 ASSERT_TRUE(ret == ERR_OK);
1676 int32_t flag = ERR_INVALID_VALUE;
1677 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1678 ASSERT_EQ(OHOS::system::GetBoolParameter(PERSIST_EDM_SET_BIOMETRICS_AND_SCREENLOCK_DISABLE, false),
1679 reply.ReadBool());
1680 }
1681
1682 /**
1683 * @tc.name: TestDisableSetBiometricsAndScreenLockQuery002
1684 * @tc.desc: Test DisableSetBiometricsAndScreenLockQuery::QueryPolicy function.
1685 * @tc.type: FUNC
1686 */
1687 HWTEST_F(PluginPolicyQueryTest, TestDisableSetBiometricsAndScreenLockQuery002, TestSize.Level1)
1688 {
1689 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableSetBiometricsAndScreenLockQuery>();
1690 std::string policyData("false");
1691 MessageParcel data;
1692 MessageParcel reply;
1693 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1694 int32_t flag = ERR_INVALID_VALUE;
1695 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1696 bool result = false;
1697 reply.ReadBool(result);
1698 ASSERT_TRUE(ret == ERR_OK);
1699 }
1700
1701 /**
1702 * @tc.name: TestDisallowExportRecoveryKeyQuery001
1703 * @tc.desc: Test DisallowExportRecoveryKeyQuery::QueryPolicy function.
1704 * @tc.type: FUNC
1705 */
1706 HWTEST_F(PluginPolicyQueryTest, TestDisallowExportRecoveryKeyQuery001, TestSize.Level1)
1707 {
1708 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowExportRecoveryKeyQuery>();
1709 std::string policyData("false");
1710 MessageParcel data;
1711 MessageParcel reply;
1712 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1713 ASSERT_TRUE(ret == ERR_OK);
1714 int32_t flag = ERR_INVALID_VALUE;
1715 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1716 bool result = true;
1717 reply.ReadBool(result);
1718 ASSERT_TRUE(!result);
1719 }
1720
1721 /**
1722 * @tc.name: TestDisallowExportRecoveryKeyQuery002
1723 * @tc.desc: Test DisallowExportRecoveryKeyQuery::QueryPolicy function.
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(PluginPolicyQueryTest, TestDisallowExportRecoveryKeyQuery002, TestSize.Level1)
1727 {
1728 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowExportRecoveryKeyQuery>();
1729 std::string policyData("true");
1730 MessageParcel data;
1731 MessageParcel reply;
1732 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1733 ASSERT_TRUE(ret == ERR_OK);
1734 int32_t flag = ERR_INVALID_VALUE;
1735 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1736 bool result = false;
1737 reply.ReadBool(result);
1738 ASSERT_TRUE(result);
1739 }
1740
1741 /**
1742 * @tc.name: TestDisallowDistributedTransmissionQuery001
1743 * @tc.desc: Test DisallowDistributedTransmissionQuery::QueryPolicy function.
1744 * @tc.type: FUNC
1745 */
1746 HWTEST_F(PluginPolicyQueryTest, TestDisallowDistributedTransmissionQuery001, TestSize.Level1)
1747 {
1748 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowDistributedTransmissionQuery>();
1749 std::string policyData("false");
1750 MessageParcel data;
1751 MessageParcel reply;
1752 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1753 ASSERT_TRUE(ret == ERR_OK);
1754 int32_t flag = ERR_INVALID_VALUE;
1755 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1756 bool result = true;
1757 reply.ReadBool(result);
1758 ASSERT_TRUE(!result);
1759 }
1760
1761 /**
1762 * @tc.name: TestDisallowDistributedTransmissionQuery002
1763 * @tc.desc: Test DisallowDistributedTransmissionQuery::QueryPolicy function.
1764 * @tc.type: FUNC
1765 */
1766 HWTEST_F(PluginPolicyQueryTest, TestDisallowDistributedTransmissionQuery002, TestSize.Level1)
1767 {
1768 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowDistributedTransmissionQuery>();
1769 std::string policyData("true");
1770 MessageParcel data;
1771 MessageParcel reply;
1772 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1773 ASSERT_TRUE(ret == ERR_OK);
1774 int32_t flag = ERR_INVALID_VALUE;
1775 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1776 bool result = false;
1777 reply.ReadBool(result);
1778 ASSERT_TRUE(result);
1779 }
1780
1781 /**
1782 * @tc.name: TestDisableSetDeviceNameQuery001
1783 * @tc.desc: Test DisableSetDeviceNameQuery::QueryPolicy function.
1784 * @tc.type: FUNC
1785 */
1786 HWTEST_F(PluginPolicyQueryTest, TestDisableSetDeviceNameQuery001, TestSize.Level1)
1787 {
1788 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableSetDeviceNameQuery>();
1789 std::string policyData("false");
1790 MessageParcel data;
1791 MessageParcel reply;
1792 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1793 ASSERT_TRUE(ret == ERR_OK);
1794 int32_t flag = ERR_INVALID_VALUE;
1795 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1796 ASSERT_EQ(OHOS::system::GetBoolParameter(PERSIST_EDM_SET_DEVICE_NAME_DISABLE, false),
1797 reply.ReadBool());
1798 }
1799
1800 /**
1801 * @tc.name: TestDisableSetDeviceNameQuery002
1802 * @tc.desc: Test DisableSetDeviceNameQuery::QueryPolicy function.
1803 * @tc.type: FUNC
1804 */
1805 HWTEST_F(PluginPolicyQueryTest, TestDisableSetDeviceNameQuery002, TestSize.Level1)
1806 {
1807 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableSetDeviceNameQuery>();
1808 std::string policyData("false");
1809 MessageParcel data;
1810 MessageParcel reply;
1811 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1812 int32_t flag = ERR_INVALID_VALUE;
1813 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1814 bool result = false;
1815 reply.ReadBool(result);
1816 ASSERT_TRUE(ret == ERR_OK);
1817 }
1818
1819 #ifdef FEATURE_PC_ONLY
1820 /**
1821 * @tc.name: TestGetAutoUnlockAfterRebootQuery001
1822 * @tc.desc: Test GetAutoUnlockAfterRebootQuery QueryPolicy function.
1823 * @tc.type: FUNC
1824 */
1825 HWTEST_F(PluginPolicyQueryTest, TestGetAutoUnlockAfterRebootQuery001, TestSize.Level1)
1826 {
1827 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetAutoUnlockAfterRebootQuery>();
1828 std::string policyData{"false"};
1829 MessageParcel data;
1830 MessageParcel reply;
1831 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1832 int32_t flag = ERR_INVALID_VALUE;
1833 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1834 bool result = false;
1835 reply.ReadBool(result);
1836 ASSERT_TRUE(ret == ERR_OK);
1837 }
1838
1839 /**
1840 * @tc.name: TestGetAutoUnlockAfterRebootQuery002
1841 * @tc.desc: Test GetAutoUnlockAfterRebootQuery QueryPolicy function.
1842 * @tc.type: FUNC
1843 */
1844 HWTEST_F(PluginPolicyQueryTest, TestGetAutoUnlockAfterRebootQuery002, TestSize.Level1)
1845 {
1846 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetAutoUnlockAfterRebootQuery>();
1847 std::string policyData{"true"};
1848 MessageParcel data;
1849 MessageParcel reply;
1850 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1851 int32_t flag = ERR_INVALID_VALUE;
1852 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1853 bool result = false;
1854 reply.ReadBool(result);
1855 ASSERT_TRUE(ret == ERR_OK);
1856 }
1857
1858 /**
1859 * @tc.name: TestGetAutoUnlockAfterRebootQuery003
1860 * @tc.desc: Test GetAutoUnlockAfterRebootQuery GetQueryName and GetPermission function.
1861 * @tc.type: FUNC
1862 */
1863 HWTEST_F(PluginPolicyQueryTest, TestGetAutoUnlockAfterRebootQuery003, TestSize.Level1)
1864 {
1865 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<GetAutoUnlockAfterRebootQuery>();
1866 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1867 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1868 == TEST_PERMISSION_ENTERPRISE_MANAGE_SYSTEM);
1869 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_SET_AUTO_UNLOCK_AFTER_REBOOT);
1870 }
1871
1872 /**
1873 * @tc.name: TestDisallowModifyEthernetIpQuery001
1874 * @tc.desc: Test DisallowModifyEthernetIpQuery QueryPolicy function return false.
1875 * @tc.type: FUNC
1876 */
1877 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyEthernetIpQuery001, TestSize.Level1)
1878 {
1879 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowModifyEthernetIpQuery>();
1880 std::string policyData{"false"};
1881 MessageParcel data;
1882 MessageParcel reply;
1883 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1884 int32_t flag = ERR_INVALID_VALUE;
1885 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1886 bool result = false;
1887 reply.ReadBool(result);
1888 ASSERT_TRUE(ret == ERR_OK);
1889 ASSERT_FALSE(result);
1890 }
1891
1892 /**
1893 * @tc.name: TestDisallowModifyEthernetIpQuery002
1894 * @tc.desc: Test DisallowModifyEthernetIpQuery QueryPolicy function return true.
1895 * @tc.type: FUNC
1896 */
1897 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyEthernetIpQuery002, TestSize.Level1)
1898 {
1899 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowModifyEthernetIpQuery>();
1900 std::string policyData{"true"};
1901 MessageParcel data;
1902 MessageParcel reply;
1903 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1904 int32_t flag = ERR_INVALID_VALUE;
1905 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1906 bool result = false;
1907 reply.ReadBool(result);
1908 ASSERT_TRUE(ret == ERR_OK);
1909 ASSERT_TRUE(result);
1910 }
1911
1912 /**
1913 * @tc.name: TestDisallowModifyEthernetIpQuery003
1914 * @tc.desc: Test DisallowModifyEthernetIpQuery GetPolicyName and GetPermission function.
1915 * @tc.type: FUNC
1916 */
1917 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyEthernetIpQuery003, TestSize.Level1)
1918 {
1919 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowModifyEthernetIpQuery>();
1920 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1921 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag) ==
1922 TEST_PERMISSION_ENTERPRISE_SET_USER_RESTRICTION);
1923 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_DISALLOW_MODIFY_ETHERNET_IP);
1924 }
1925
1926 /**
1927 * @tc.name: DisableUsbStorageDeviceWriteQuery001
1928 * @tc.desc: Test DisableUserMtpPluginTest::QueryPolicy function.
1929 * @tc.type: FUNC
1930 */
1931 HWTEST_F(PluginPolicyQueryTest, TestDisableUsbStorageDeviceWriteQuery001, TestSize.Level1)
1932 {
1933 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableUsbStorageDeviceWriteQuery>();
1934 std::string policyData{"false"};
1935 MessageParcel data;
1936 MessageParcel reply;
1937 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1938 int32_t flag = ERR_INVALID_VALUE;
1939 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1940 bool result = false;
1941 reply.ReadBool(result);
1942 ASSERT_TRUE(ret == ERR_OK);
1943 ASSERT_FALSE(result);
1944 }
1945
1946 /**
1947 * @tc.name: TestDisableUsbStorageDeviceWriteQuery002
1948 * @tc.desc: Test DisableUsbStorageDeviceWriteQuery GetPolicyName and GetPermission function.
1949 * @tc.type: FUNC
1950 */
1951 HWTEST_F(PluginPolicyQueryTest, TestDisableUsbStorageDeviceWriteQuery002, TestSize.Level1)
1952 {
1953 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableUsbStorageDeviceWriteQuery>();
1954 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1955 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1956 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1957 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_usb_storage_device_write");
1958 }
1959
1960 #endif
1961
1962 #ifdef NETMANAGER_EXT_EDM_ENABLE
1963 /**
1964 * @tc.name: TestDisallowVPNQuery001
1965 * @tc.desc: Test DisallowVPNQuery QueryPolicy function.
1966 * @tc.type: FUNC
1967 */
1968 HWTEST_F(PluginPolicyQueryTest, TestDisallowVPNQuery001, TestSize.Level1)
1969 {
1970 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowVPNQuery>();
1971 std::string policyData{"false"};
1972 MessageParcel data;
1973 MessageParcel reply;
1974 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
1975 int32_t flag = ERR_INVALID_VALUE;
1976 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
1977 bool result = false;
1978 reply.ReadBool(result);
1979 ASSERT_TRUE(ret == ERR_OK);
1980 }
1981
1982 /**
1983 * @tc.name: TestDisallowVPNQuery002
1984 * @tc.desc: Test DisallowVPNQuery GetPolicyName and GetPermission function.
1985 * @tc.type: FUNC
1986 */
1987 HWTEST_F(PluginPolicyQueryTest, TestDisallowVPNQuery002, TestSize.Level1)
1988 {
1989 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowVPNQuery>();
1990 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
1991 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
1992 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
1993 ASSERT_TRUE(queryObj->GetPolicyName() == "disallow_vpn");
1994 }
1995 #endif
1996
1997 #ifdef SUDO_EDM_ENABLE
1998 /**
1999 * @tc.name: DisableSudoQuery001
2000 * @tc.desc: Test DisableSudoPluginTest::QueryPolicy function.
2001 * @tc.type: FUNC
2002 */
2003 HWTEST_F(PluginPolicyQueryTest, TestDisableSudoQuery001, TestSize.Level1)
2004 {
2005 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableSudoQuery>();
2006 std::string policyData{"false"};
2007 MessageParcel data;
2008 MessageParcel reply;
2009 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
2010 int32_t flag = ERR_INVALID_VALUE;
2011 ASSERT_TRUE(reply.ReadInt32(flag));
2012 ASSERT_EQ(flag, ERR_OK);
2013 bool result = false;
2014 ASSERT_TRUE(reply.ReadBool(result));
2015 ASSERT_TRUE(ret == ERR_OK);
2016 ASSERT_FALSE(result);
2017 }
2018 #endif
2019
2020 #ifdef FEATURE_PC_ONLY
2021 /**
2022 * @tc.name: DisablePrintQuery001
2023 * @tc.desc: Test DisablePrintPluginTest::QueryPolicy function.
2024 * @tc.type: FUNC
2025 */
2026 HWTEST_F(PluginPolicyQueryTest, TestDisablePrintQuery001, TestSize.Level1)
2027 {
2028 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisablePrintQuery>();
2029 std::string policyData{"false"};
2030 MessageParcel data;
2031 MessageParcel reply;
2032 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
2033 int32_t flag = ERR_INVALID_VALUE;
2034 ASSERT_TRUE(reply.ReadInt32(flag));
2035 ASSERT_EQ(flag, ERR_OK);
2036 bool result = false;
2037 ASSERT_TRUE(reply.ReadBool(result));
2038 ASSERT_TRUE(ret == ERR_OK);
2039 ASSERT_FALSE(result);
2040 }
2041 #endif
2042
2043 #ifdef PRIVATE_SPACE_EDM_ENABLE
2044 /**
2045 * @tc.name: TestDisablePrivateSpaceQuery001
2046 * @tc.desc: Test DisablePrivateSpaceQuery QueryPolicy function.
2047 * @tc.type: FUNC
2048 */
2049 HWTEST_F(PluginPolicyQueryTest, TestDisablePrivateSpaceQuery001, TestSize.Level1)
2050 {
2051 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisablePrivateSpaceQuery>();
2052 std::string policyData{"false"};
2053 MessageParcel data;
2054 MessageParcel reply;
2055 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
2056 int32_t flag = ERR_INVALID_VALUE;
2057 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
2058 bool result = false;
2059 reply.ReadBool(result);
2060 ASSERT_TRUE(ret == ERR_OK);
2061 }
2062
2063 /**
2064 * @tc.name: TestDisablePrivateSpaceQuery002
2065 * @tc.desc: Test DisablePrivateSpaceQuery GetPolicyName and GetPermission function.
2066 * @tc.type: FUNC
2067 */
2068 HWTEST_F(PluginPolicyQueryTest, TestDisablePrivateSpaceQuery002, TestSize.Level1)
2069 {
2070 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisablePrivateSpaceQuery>();
2071 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
2072 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
2073 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
2074 ASSERT_TRUE(queryObj->GetPolicyName() == PolicyName::POLICY_DISABLED_PRIVATE_SPACE);
2075 }
2076 #endif
2077
2078 #ifdef NOTIFICATION_EDM_ENABLE
2079 /**
2080 * @tc.name: TestDisallowedNotificationQuery001
2081 * @tc.desc: Test DisallowedNotificationQuery QueryPolicy function.
2082 * @tc.type: FUNC
2083 */
2084 HWTEST_F(PluginPolicyQueryTest, TestDisallowedNotificationQuery001, TestSize.Level1)
2085 {
2086 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedNotificationQuery>();
2087 std::string policyData{"false"};
2088 MessageParcel data;
2089 MessageParcel reply;
2090 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
2091 int32_t flag = ERR_INVALID_VALUE;
2092 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
2093 bool result = false;
2094 reply.ReadBool(result);
2095 ASSERT_TRUE(ret == ERR_OK);
2096 }
2097
2098 /**
2099 * @tc.name: TestDisallowedNotificationQuery002
2100 * @tc.desc: Test DisallowedNotificationQuery GetPolicyName and GetPermission function.
2101 * @tc.type: FUNC
2102 */
2103 HWTEST_F(PluginPolicyQueryTest, TestDisallowedNotificationQuery002, TestSize.Level1)
2104 {
2105 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisallowedNotificationQuery>();
2106 std::string permissionTag = TEST_PERMISSION_TAG_VERSION_11;
2107 ASSERT_TRUE(queryObj->GetPermission(IPlugin::PermissionType::SUPER_DEVICE_ADMIN, permissionTag)
2108 == TEST_PERMISSION_ENTERPRISE_MANAGE_RESTRICTIONS);
2109 ASSERT_TRUE(queryObj->GetPolicyName() == "disallowed_notification");
2110 }
2111 #endif
2112
2113 } // namespace TEST
2114 } // namespace EDM
2115 } // namespace OHOS
2116