1/*
2 * Copyright (c) 2022-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 "UTTest_permission_manager.h"
17#include "accesstoken_kit.h"
18#include "nativetoken_kit.h"
19#include "token_setproc.h"
20
21namespace OHOS {
22namespace DistributedHardware {
23void PermissionManagerTest::SetUp()
24{
25    const int32_t permsNum = 2;
26    const int32_t indexZero = 0;
27    const int32_t indexOne = 1;
28    uint64_t tokenId;
29    const char *perms[permsNum];
30    perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
31    perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
32    NativeTokenInfoParams infoInstance = {
33        .dcapsNum = 0,
34        .permsNum = permsNum,
35        .aclsNum = 0,
36        .dcaps = NULL,
37        .perms = perms,
38        .acls = NULL,
39        .processName = "dsoftbus_service",
40        .aplStr = "system_core",
41    };
42    tokenId = GetAccessTokenId(&infoInstance);
43    SetSelfTokenID(tokenId);
44    OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
45}
46constexpr int32_t PAKAGE_NAME_SIZE_MAX = 256;
47#define AUTH_CODE_WHITE_LIST_NUM (3)
48constexpr const static char g_authCodeWhiteList[AUTH_CODE_WHITE_LIST_NUM][PAKAGE_NAME_SIZE_MAX] = {
49    "com.huawei.msdp.hmringgenerator",
50    "com.huawei.msdp.hmringdiscriminator",
51    "CollaborationFwk",
52};
53
54#define PIN_HOLDER_WHITE_LIST_NUM (1)
55constexpr const static char g_pinHolderWhiteList[PIN_HOLDER_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = {
56    "CollaborationFwk",
57};
58
59#define SYSTEM_SA_WHITE_LIST_NUM (4)
60constexpr const static char systemSaWhiteList[SYSTEM_SA_WHITE_LIST_NUM][PAKAGE_NAME_SIZE_MAX] = {
61    "Samgr_Networking",
62    "ohos.distributeddata.service",
63    "ohos.dslm",
64    "ohos.deviceprofile",
65};
66void PermissionManagerTest::TearDown()
67{
68}
69
70void PermissionManagerTest::SetUpTestCase()
71{
72}
73
74void PermissionManagerTest::TearDownTestCase()
75{
76}
77
78namespace {
79
80/**
81 * @tc.name: PinAuthUi::CheckPermission_001
82 * @tc.desc: the return value is true
83 * @tc.type: FUNC
84 * @tc.require: AR000GHSJK
85 */
86HWTEST_F(PermissionManagerTest, CheckPermission_001, testing::ext::TestSize.Level0)
87{
88    bool ret = PermissionManager::GetInstance().CheckPermission();
89    ASSERT_EQ(ret, true);
90}
91
92/**
93 * @tc.name: PinAuthUi::GetCallerProcessName_001
94 * @tc.desc: the return value is not DM_OK
95 * @tc.type: FUNC
96 * @tc.require: AR000GHSJK
97 */
98HWTEST_F(PermissionManagerTest, GetCallerProcessName_001, testing::ext::TestSize.Level0)
99{
100    std::string processName;
101    int32_t ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
102    ASSERT_EQ(ret, DM_OK);
103}
104
105/**
106 * @tc.name: PinAuthUi::CheckProcessNameValidOnAuthCode_001
107 * @tc.desc: the return value is false
108 * @tc.type: FUNC
109 * @tc.require: AR000GHSJK
110 */
111HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_001, testing::ext::TestSize.Level0)
112{
113    std::string processName;
114    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName);
115    ASSERT_EQ(ret, false);
116}
117
118/**
119 * @tc.name: PinAuthUi::CheckProcessNameValidOnAuthCode_002
120 * @tc.desc: the return value is false
121 * @tc.type: FUNC
122 * @tc.require: AR000GHSJK
123 */
124HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_002, testing::ext::TestSize.Level0)
125{
126    std::string processName = "processName";
127    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName);
128    ASSERT_EQ(ret, false);
129}
130
131/**
132 * @tc.name: PinAuthUi::CheckProcessNameValidOnAuthCode_003
133 * @tc.desc: the return value is true
134 * @tc.type: FUNC
135 * @tc.require: AR000GHSJK
136 */
137HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_003, testing::ext::TestSize.Level0)
138{
139    std::string processName1(g_authCodeWhiteList[0]);
140    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName1);
141    ASSERT_EQ(ret, true);
142    std::string processName2(g_authCodeWhiteList[1]);
143    ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName2);
144    ASSERT_EQ(ret, true);
145    std::string processName3(g_authCodeWhiteList[2]);
146    ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName3);
147    ASSERT_EQ(ret, true);
148}
149
150HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_004, testing::ext::TestSize.Level0)
151{
152    std::string processName = "CollaborationFwk";
153    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName);
154    ASSERT_TRUE(ret);
155}
156/**
157 * @tc.name: PinAuthUi::CheckProcessNameValidOnPinHolder_001
158 * @tc.desc: the return value is false
159 * @tc.type: FUNC
160 * @tc.require: AR000GHSJK
161 */
162HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_001, testing::ext::TestSize.Level0)
163{
164    std::string processName;
165    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName);
166    ASSERT_EQ(ret, false);
167}
168
169/**
170 * @tc.name: PinAuthUi::CheckProcessNameValidOnPinHolder_002
171 * @tc.desc: the return value is false
172 * @tc.type: FUNC
173 * @tc.require: AR000GHSJK
174 */
175HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_002, testing::ext::TestSize.Level0)
176{
177    std::string processName = "processName";
178    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName);
179    ASSERT_EQ(ret, false);
180}
181
182/**
183 * @tc.name: PinAuthUi::CheckProcessNameValidOnPinHolder_003
184 * @tc.desc: the return value is true
185 * @tc.type: FUNC
186 * @tc.require: AR000GHSJK
187 */
188HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_003, testing::ext::TestSize.Level0)
189{
190    std::string processName1(g_pinHolderWhiteList[0]);
191    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName1);
192    ASSERT_EQ(ret, true);
193}
194
195HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_004, testing::ext::TestSize.Level0)
196{
197    std::string processName = "CollaborationFwk";
198    bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName);
199    ASSERT_TRUE(ret);
200}
201/**
202 * @tc.name: PinAuthUi::CheckSystemSA_001
203 * @tc.desc: the return value is false
204 * @tc.type：FUNC
205 * @tc.require: AR000GHSJK
206*/
207HWTEST_F(PermissionManagerTest, CheckSystemSA_001, testing::ext::TestSize.Level0)
208{
209    std::string pkgName;
210    bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
211    ASSERT_EQ(ret, false);
212    pkgName = "pkgName";
213    ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
214    ASSERT_EQ(ret, false);
215}
216
217/**
218 * @tc.name: PinAuthUi::CheckSystemSA_002
219 * @tc.desc: the return value is true
220 * @tc.type：FUNC
221 * @tc.require: AR000GHSJK
222*/
223HWTEST_F(PermissionManagerTest, CheckSystemSA_002, testing::ext::TestSize.Level0)
224{
225    std::string pkgName1(systemSaWhiteList[0]);
226    bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName1);
227    ASSERT_EQ(ret, true);
228    std::string pkgName2(systemSaWhiteList[1]);
229    ret = PermissionManager::GetInstance().CheckSystemSA(pkgName2);
230    ASSERT_EQ(ret, true);
231    std::string pkgName3(systemSaWhiteList[2]);
232    ret = PermissionManager::GetInstance().CheckSystemSA(pkgName3);
233    ASSERT_EQ(ret, true);
234    std::string pkgName4(systemSaWhiteList[3]);
235    ret = PermissionManager::GetInstance().CheckSystemSA(pkgName4);
236    ASSERT_EQ(ret, true);
237}
238
239HWTEST_F(PermissionManagerTest, CheckSystemSA_101, testing::ext::TestSize.Level0)
240{
241    std::string pkgName = "pkgName";
242    bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
243    ASSERT_FALSE(ret);
244}
245
246HWTEST_F(PermissionManagerTest, CheckSystemSA_102, testing::ext::TestSize.Level0)
247{
248    std::string pkgName = "ohos.dhardware";
249    bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
250    ASSERT_TRUE(ret);
251}
252}
253} // namespace DistributedHardware
254} // namespace OHOS