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 "1.0/include/screen_manager_adapter_test.h"
17 
18 #include "common/include/screen_manager_adapter.h"
19 #include "dscreen_constants.h"
20 #include "dscreen_errcode.h"
21 #include "dscreen_util.h"
22 #include "video_param.h"
23 #include "accesstoken_kit.h"
24 #include "nativetoken_kit.h"
25 #include "token_setproc.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace DistributedHardware {
32 constexpr static uint32_t VIDEO_DATA_NUM = 480;
SetUpTestCase(void)33 void DScreenManagerAdapterTest::SetUpTestCase(void) {}
34 
TearDownTestCase(void)35 void DScreenManagerAdapterTest::TearDownTestCase(void) {}
36 
SetUp(void)37 void DScreenManagerAdapterTest::SetUp(void) {}
38 
TearDown(void)39 void DScreenManagerAdapterTest::TearDown(void) {}
40 
EnablePermissionAccess(const char * perms[],size_t permsNum,uint64_t & tokenId)41 void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId)
42 {
43     NativeTokenInfoParams infoInstance = {
44         .dcapsNum = 0,
45         .permsNum = permsNum,
46         .aclsNum = 0,
47         .dcaps = nullptr,
48         .perms = perms,
49         .acls = nullptr,
50         .aplStr = "system_basic",
51     };
52 
53     infoInstance.processName = "DscreenMgrTest";
54     tokenId = GetAccessTokenId(&infoInstance);
55     SetSelfTokenID(tokenId);
56     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
57 }
58 
DisablePermissionAccess(const uint64_t & tokenId)59 void DisablePermissionAccess(const uint64_t &tokenId)
60 {
61     OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId);
62 }
63 
64 /**
65  * @tc.name: CreateVirtualScreen_001
66  * @tc.desc: Verify the CreateVirtualScreen function failed.
67  * @tc.type: FUNC
68  * @tc.require: Issue Number
69  */
70 HWTEST_F(DScreenManagerAdapterTest, CreateVirtualScreen_001, TestSize.Level1)
71 {
72     std::string devId;
73     std::string dhId;
74     std::shared_ptr<VideoParam> videoParam = nullptr;
75     uint64_t ret = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam);
76     EXPECT_EQ(SCREEN_ID_INVALID, ret);
77 }
78 
79 /**
80  * @tc.name: CreateVirtualScreen_002
81  * @tc.desc: Verify the CreateVirtualScreen function failed.
82  * @tc.type: FUNC
83  * @tc.require: Issue Number
84  */
85 HWTEST_F(DScreenManagerAdapterTest, CreateVirtualScreen_002, TestSize.Level1)
86 {
87     std::string devId = "devId";
88     std::string dhId = "dhId";
89     std::shared_ptr<VideoParam> videoParam = std::make_shared<VideoParam>();
90     std::string screenName = DSCREEN_PREFIX + SEPERATOR + GetInterruptString(devId) +
91                              SEPERATOR + GetInterruptString(dhId);
92     ScreenMgrAdapter::GetInstance().screenIdMap_.emplace(screenName, 100);
93     uint64_t ret = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam);
94     EXPECT_EQ(SCREEN_ID_INVALID, ret);
95 }
96 
97 /**
98  * @tc.name: CreateVirtualScreen_003
99  * @tc.desc: Verify the CreateVirtualScreen function failed.
100  * @tc.type: FUNC
101  * @tc.require: Issue Number
102  */
103 HWTEST_F(DScreenManagerAdapterTest, CreateVirtualScreen_003, TestSize.Level1)
104 {
105     std::string devId = "devId";
106     std::string dhId = "dhId";
107     ScreenMgrAdapter::GetInstance().screenIdMap_.clear();
108     std::shared_ptr<VideoParam> videoParam = std::make_shared<VideoParam>();
109     uint64_t ret = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam);
110     EXPECT_EQ(1, ScreenMgrAdapter::GetInstance().screenIdMap_.size());
111 
112     ret = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam);
113     EXPECT_EQ(1, ScreenMgrAdapter::GetInstance().screenIdMap_.size());
114     ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(ret);
115     ScreenMgrAdapter::GetInstance().screenIdMap_.clear();
116 }
117 
118 /**
119  * @tc.name: RegisterScreenGroupListener_001
120  * @tc.desc: Verify the RegisterScreenGroupListener function failed.
121  * @tc.type: FUNC
122  * @tc.require: Issue Number
123  */
124 HWTEST_F(DScreenManagerAdapterTest, RegisterScreenGroupListener_001, TestSize.Level1)
125 {
126     sptr<Rosen::ScreenManager::IScreenGroupListener> listener = nullptr;
127     int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(listener);
128     EXPECT_EQ(ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL, ret);
129 }
130 
131 /**
132  * @tc.name: RegisterScreenGroupListener_002
133  * @tc.desc: Verify the RegisterScreenGroupListener function failed.
134  * @tc.type: FUNC
135  * @tc.require: Issue Number
136  */
137 HWTEST_F(DScreenManagerAdapterTest, RegisterScreenGroupListener_002, TestSize.Level1)
138 {
139     sptr<Rosen::ScreenManager::IScreenGroupListener> listener(new MockScreenGroupListener());
140     ScreenMgrAdapter::GetInstance().listenerRegistered_ = true;
141     int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(listener);
142     EXPECT_EQ(DH_SUCCESS, ret);
143 }
144 
145 /**
146  * @tc.name: RegisterScreenGroupListener_003
147  * @tc.desc: Verify the RegisterScreenGroupListener function failed.
148  * @tc.type: FUNC
149  * @tc.require: Issue Number
150  */
151 HWTEST_F(DScreenManagerAdapterTest, RegisterScreenGroupListener_003, TestSize.Level1)
152 {
153     sptr<Rosen::ScreenManager::IScreenGroupListener> listener(new MockScreenGroupListener());
154     ScreenMgrAdapter::GetInstance().listenerRegistered_ = false;
155     int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(listener);
156     EXPECT_EQ(DH_SUCCESS, ret);
157     ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(listener);
158 }
159 
160 /**
161  * @tc.name: UnregisterScreenGroupListener_001
162  * @tc.desc: Verify the UnregisterScreenGroupListener function failed.
163  * @tc.type: FUNC
164  * @tc.require: Issue Number
165  */
166 HWTEST_F(DScreenManagerAdapterTest, UnregisterScreenGroupListener_001, TestSize.Level1)
167 {
168     sptr<Rosen::ScreenManager::IScreenGroupListener> listener = nullptr;
169     int32_t ret = ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(listener);
170     ScreenMgrAdapter::GetInstance().RemoveScreenFromGroup(100);
171     EXPECT_EQ(ERR_DH_SCREEN_SA_UNREGISTER_SCREENLISTENER_FAIL, ret);
172 }
173 
174 /**
175  * @tc.name: UnregisterScreenGroupListener_002
176  * @tc.desc: Verify the UnregisterScreenGroupListener function failed.
177  * @tc.type: FUNC
178  * @tc.require: Issue Number
179  */
180 HWTEST_F(DScreenManagerAdapterTest, UnregisterScreenGroupListener_002, TestSize.Level1)
181 {
182     sptr<Rosen::ScreenManager::IScreenGroupListener> listener(new MockScreenGroupListener());
183     ScreenMgrAdapter::GetInstance().listenerRegistered_ = false;
184     int32_t ret = ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(listener);
185     EXPECT_EQ(DH_SUCCESS, ret);
186 }
187 
188 /**
189  * @tc.name: UnregisterScreenGroupListener_003
190  * @tc.desc: Verify the UnregisterScreenGroupListener function failed.
191  * @tc.type: FUNC
192  * @tc.require: Issue Number
193  */
194 HWTEST_F(DScreenManagerAdapterTest, UnregisterScreenGroupListener_003, TestSize.Level1)
195 {
196     sptr<Rosen::ScreenManager::IScreenGroupListener> listener(new MockScreenGroupListener());
197     ScreenMgrAdapter::GetInstance().listenerRegistered_ = true;
198     int32_t ret = ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(listener);
199     EXPECT_EQ(ERR_DH_SCREEN_SA_UNREGISTER_SCREENLISTENER_FAIL, ret);
200 }
201 
202 /**
203  * @tc.name: RemoveVirtualScreen_001
204  * @tc.desc: Verify the RemoveVirtualScreen function failed.
205  * @tc.type: FUNC
206  * @tc.require: Issue Number
207  */
208 HWTEST_F(DScreenManagerAdapterTest, RemoveVirtualScreen_001, TestSize.Level1)
209 {
210     int32_t ret = ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(100);
211     EXPECT_EQ(ERR_DH_SCREEN_SA_REMOVE_VIRTUALSCREEN_FAIL, ret);
212 }
213 
214 /**
215  * @tc.name: SetImageSurface_001
216  * @tc.desc: Verify the SetImageSurface function failed.
217  * @tc.type: FUNC
218  * @tc.require: Issue Number
219  */
220 HWTEST_F(DScreenManagerAdapterTest, SetImageSurface_001, TestSize.Level1)
221 {
222     sptr<OHOS::Surface> surface = nullptr;
223     uint64_t screenId = 0;
224     int32_t ret = ScreenMgrAdapter::GetInstance().SetImageSurface(screenId, surface);
225     EXPECT_EQ(ERR_DH_SCREEN_SA_SET_IMAGESURFACE_FAIL, ret);
226 }
227 
228 /**
229  * @tc.name: GetMapRelation_001
230  * @tc.desc: Verify the GetMapRelation function failed.
231  * @tc.type: FUNC
232  * @tc.require: Issue Number
233  */
234 HWTEST_F(DScreenManagerAdapterTest, GetMapRelation_001, TestSize.Level1)
235 {
236     std::shared_ptr<DScreenMapRelation> ret = ScreenMgrAdapter::GetInstance().GetMapRelation(100000);
237     EXPECT_EQ(nullptr, ret);
238 }
239 
240 /**
241  * @tc.name: GetMapRelation_002
242  * @tc.desc: Verify the GetMapRelation function failed.
243  * @tc.type: FUNC
244  * @tc.require: Issue Number
245  */
246 HWTEST_F(DScreenManagerAdapterTest, GetMapRelation_002, TestSize.Level1)
247 {
248     const char* perms[] = {
249         "ohos.permission.DISTRIBUTED_DATASYNC",
250         "ohos.permission.CAPTURE_SCREEN",
251     };
252     EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_);
253     std::string devId = "devId";
254     std::string dhId = "dhId";
255     ScreenMgrAdapter::GetInstance().screenIdMap_.clear();
256     std::shared_ptr<VideoParam> videoParam = std::make_shared<VideoParam>();
257     videoParam->SetScreenWidth(VIDEO_DATA_NUM);
258     videoParam->SetScreenHeight(VIDEO_DATA_NUM);
259     uint64_t screenId = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam);
260     std::shared_ptr<DScreenMapRelation> ret = ScreenMgrAdapter::GetInstance().GetMapRelation(screenId);
261     ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(screenId);
262     ScreenMgrAdapter::GetInstance().screenIdMap_.clear();
263     DisablePermissionAccess(tokenId_);
264     EXPECT_NE(nullptr, ret);
265 }
266 }  // namespace DistributedHardware
267 }  // namespace OHOS
268