1 /*
2  * Copyright (c) 2021-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 "distributed_input_sinkmanager_test.h"
17 
18 #include "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "if_system_ability_manager.h"
21 #include "iservice_registry.h"
22 #include "system_ability_definition.h"
23 #include "nativetoken_kit.h"
24 #include "token_setproc.h"
25 #include "softbus_common.h"
26 
27 #include "dinput_errcode.h"
28 #include "mock_process.h"
29 
30 using namespace testing::ext;
31 using namespace OHOS::Security::AccessToken;
32 using namespace OHOS::DistributedHardware::DistributedInput;
33 using namespace std;
34 namespace OHOS {
35 namespace DistributedHardware {
36 namespace DistributedInput {
SetUp()37 void DistributedInputSinkManagerTest::SetUp()
38 {
39     sinkManager_ = new DistributedInputSinkManager(DISTRIBUTED_HARDWARE_INPUT_SINK_SA_ID, true);
40     if (sinkManager_ != nullptr) {
41         sinkManager_->Init();
42     }
43 
44     uint64_t tokenId;
45     const char *perms[2];
46     perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
47     perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
48     NativeTokenInfoParams infoInstance = {
49         .dcapsNum = 0,
50         .permsNum = 2,
51         .aclsNum = 0,
52         .dcaps = NULL,
53         .perms = perms,
54         .acls = NULL,
55         .processName = "dsoftbus_service",
56         .aplStr = "system_core",
57     };
58     tokenId = GetAccessTokenId(&infoInstance);
59     SetSelfTokenID(tokenId);
60     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
61 }
62 
TearDown()63 void DistributedInputSinkManagerTest::TearDown()
64 {
65 }
66 
SetUpTestCase()67 void DistributedInputSinkManagerTest::SetUpTestCase()
68 {
69 }
70 
TearDownTestCase()71 void DistributedInputSinkManagerTest::TearDownTestCase()
72 {
73 }
74 
OnResult(const std::string & strJson)75 void DistributedInputSinkManagerTest::TestGetSinkScreenInfosCb::OnResult(const std::string &strJson)
76 {
77     (void)strJson;
78 }
79 
OnSharing(const std::string & dhId)80 int32_t DistributedInputSinkManagerTest::TestSharingDhIdListenerStub::OnSharing(const std::string &dhId)
81 {
82     (void)dhId;
83     return DH_SUCCESS;
84 }
85 
OnNoSharing(const std::string & dhId)86 int32_t DistributedInputSinkManagerTest::TestSharingDhIdListenerStub::OnNoSharing(const std::string &dhId)
87 {
88     (void)dhId;
89     return DH_SUCCESS;
90 }
91 
92 HWTEST_F(DistributedInputSinkManagerTest, InitAuto, testing::ext::TestSize.Level0)
93 {
94     ASSERT_NE(nullptr, sinkManager_);
95     bool ret = sinkManager_->InitAuto();
96     EXPECT_EQ(true, ret);
97 }
98 
99 HWTEST_F(DistributedInputSinkManagerTest, Init, testing::ext::TestSize.Level0)
100 {
101     ASSERT_NE(nullptr, sinkManager_);
102     int32_t ret = sinkManager_->Init();
103     EXPECT_EQ(DH_SUCCESS, ret);
104 }
105 
106 HWTEST_F(DistributedInputSinkManagerTest, Release, testing::ext::TestSize.Level0)
107 {
108     ASSERT_NE(nullptr, sinkManager_);
109     MockProcess::MockDinputProcess("dinput");
110     int32_t ret = sinkManager_->Release();
111     EXPECT_EQ(DH_SUCCESS, ret);
112 }
113 
114 HWTEST_F(DistributedInputSinkManagerTest, GetStartTransFlag, testing::ext::TestSize.Level0)
115 {
116     ASSERT_NE(nullptr, sinkManager_);
117     DInputServerType flag = DInputServerType::SINK_SERVER_TYPE;
118     sinkManager_->SetStartTransFlag(flag);
119     DInputServerType retFlag = sinkManager_->GetStartTransFlag();
120     EXPECT_EQ(flag, retFlag);
121 }
122 
123 HWTEST_F(DistributedInputSinkManagerTest, GetInputTypes, testing::ext::TestSize.Level0)
124 {
125     ASSERT_NE(nullptr, sinkManager_);
126     uint32_t inputTypes = static_cast<uint32_t>(DInputDeviceType::MOUSE);
127     sinkManager_->SetInputTypes(inputTypes);
128     uint32_t retType = sinkManager_->GetInputTypes();
129     EXPECT_EQ(inputTypes, retType);
130 }
131 
132 HWTEST_F(DistributedInputSinkManagerTest, DeleteStopDhids01, testing::ext::TestSize.Level0)
133 {
134     ASSERT_NE(nullptr, sinkManager_);
135     int32_t sessionId = 1;
136     std::vector<std::string> stopDhIds;
137     std::vector<std::string> stopIndeedDhIds;
138     stopDhIds.push_back("Input_123123123123");
139     for (auto iter : stopDhIds) {
140         sinkManager_->sharingDhIds_.insert(iter);
141     }
142     sinkManager_->sharingDhIdsMap_[sessionId] = sinkManager_->sharingDhIds_;
143     sinkManager_->DeleteStopDhids(100, stopDhIds, stopIndeedDhIds);
144     sinkManager_->DeleteStopDhids(sessionId, stopDhIds, stopIndeedDhIds);
145     EXPECT_EQ(0, sinkManager_->sharingDhIdsMap_.size());
146 }
147 
148 HWTEST_F(DistributedInputSinkManagerTest, GetSinkScreenInfosCbackSize01, testing::ext::TestSize.Level0)
149 {
150     ASSERT_NE(nullptr, sinkManager_);
151     uint32_t ret = sinkManager_->GetSinkScreenInfosCbackSize();
152     EXPECT_EQ(0, ret);
153 }
154 
155 HWTEST_F(DistributedInputSinkManagerTest, RegisterGetSinkScreenInfosCallback_01, testing::ext::TestSize.Level1)
156 {
157     ASSERT_NE(nullptr, sinkManager_);
158     sptr<TestGetSinkScreenInfosCb> callback(new TestGetSinkScreenInfosCb());
159     int32_t ret = sinkManager_->RegisterGetSinkScreenInfosCallback(callback);
160     EXPECT_EQ(DH_SUCCESS, ret);
161 }
162 
163 HWTEST_F(DistributedInputSinkManagerTest, RegisterGetSinkScreenInfosCallback_02, testing::ext::TestSize.Level1)
164 {
165     ASSERT_NE(nullptr, sinkManager_);
166     sptr<TestGetSinkScreenInfosCb> callback = nullptr;
167     int32_t ret = sinkManager_->RegisterGetSinkScreenInfosCallback(callback);
168     EXPECT_EQ(DH_SUCCESS, ret);
169 }
170 
171 HWTEST_F(DistributedInputSinkManagerTest, OnMessage_01, testing::ext::TestSize.Level1)
172 {
173     ASSERT_NE(nullptr, sinkManager_);
174     int32_t fd = 1;
175     std::vector<std::u16string> args;
176     int32_t ret = sinkManager_->Dump(fd, args);
177     sinkManager_->OnStart();
178     sinkManager_->OnStop();
179     std::string message = "";
180     sinkManager_->projectWindowListener_->OnMessage(DHTopic::TOPIC_START_DSCREEN, message);
181     sinkManager_->projectWindowListener_->OnMessage(DHTopic::TOPIC_SINK_PROJECT_WINDOW_INFO, message);
182     EXPECT_EQ(ERR_DH_INPUT_HIDUMP_DUMP_PROCESS_FAIL, ret);
183 }
184 
185 HWTEST_F(DistributedInputSinkManagerTest, ParseMessage_01, testing::ext::TestSize.Level1)
186 {
187     ASSERT_NE(nullptr, sinkManager_);
188     std::string message = "";
189     std::string srcDeviceId = "";
190     uint64_t srcWinId = 0;
191     SinkScreenInfo sinkScreenInfo;
192     int32_t ret = sinkManager_->projectWindowListener_->ParseMessage(message, srcDeviceId, srcWinId, sinkScreenInfo);
193     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
194 }
195 
196 HWTEST_F(DistributedInputSinkManagerTest, ParseMessage_02, testing::ext::TestSize.Level1)
197 {
198     ASSERT_NE(nullptr, sinkManager_);
199     std::string srcDevId = "umkyu1b165e1be98151891erbe8r91ev";
200     uint64_t srcWinId = 1;
201     uint64_t sinkShowWinId = 1;
202     uint32_t sinkShowWidth = 1860;
203     uint32_t sinkShowHeigth = 980;
204     uint32_t sinkShowX = 100;
205     uint32_t sinkShowY = 100;
206     nlohmann::json jsonObj;
207     jsonObj[SOURCE_DEVICE_ID] = srcDevId;
208     jsonObj[SOURCE_WINDOW_ID] = srcWinId;
209     jsonObj[SINK_SHOW_WINDOW_ID] = sinkShowWinId;
210     jsonObj[SINK_PROJECT_SHOW_WIDTH] = sinkShowWidth;
211     jsonObj[SINK_PROJECT_SHOW_HEIGHT] = sinkShowHeigth;
212     jsonObj[SINK_WINDOW_SHOW_X] = sinkShowX;
213     jsonObj[SINK_WINDOW_SHOW_Y] = sinkShowY;
214     SinkScreenInfo sinkScreenInfo;
215     int32_t ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
216         srcDevId, srcWinId, sinkScreenInfo);
217     EXPECT_EQ(DH_SUCCESS, ret);
218 }
219 
220 HWTEST_F(DistributedInputSinkManagerTest, ParseMessage_04, testing::ext::TestSize.Level1)
221 {
222     ASSERT_NE(nullptr, sinkManager_);
223     std::string srcDevId = "umkyu1b165e1be98151891erbe8r91ev";
224     SinkScreenInfo sinkScreenInfo;
225     uint64_t srcWinId = 1;
226     uint64_t sinkShowWinId = 1;
227     uint32_t sinkShowWidth = 1860;
228     uint32_t sinkShowHeigth = 980;
229     uint32_t sinkShowX = 100;
230     nlohmann::json jsonObj;
231     jsonObj[SOURCE_DEVICE_ID] = srcWinId;
232     int32_t ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
233         srcDevId, srcWinId, sinkScreenInfo);
234     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
235 
236     jsonObj[SOURCE_DEVICE_ID] = srcDevId;
237     jsonObj[SOURCE_WINDOW_ID] = srcDevId;
238     ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
239         srcDevId, srcWinId, sinkScreenInfo);
240     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
241 
242     jsonObj[SOURCE_WINDOW_ID] = srcWinId;
243     jsonObj[SINK_SHOW_WINDOW_ID] = srcDevId;
244     ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
245         srcDevId, srcWinId, sinkScreenInfo);
246     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
247 
248     jsonObj[SINK_SHOW_WINDOW_ID] = sinkShowWinId;
249     jsonObj[SINK_PROJECT_SHOW_WIDTH] = srcDevId;
250     ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
251         srcDevId, srcWinId, sinkScreenInfo);
252     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
253 
254     jsonObj[SINK_PROJECT_SHOW_WIDTH] = sinkShowWidth;
255     jsonObj[SINK_PROJECT_SHOW_HEIGHT] = srcDevId;
256     ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
257         srcDevId, srcWinId, sinkScreenInfo);
258     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
259 
260     jsonObj[SINK_PROJECT_SHOW_HEIGHT] = sinkShowHeigth;
261     jsonObj[SINK_WINDOW_SHOW_X] = srcDevId;
262     ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
263         srcDevId, srcWinId, sinkScreenInfo);
264     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
265 
266     jsonObj[SINK_WINDOW_SHOW_X] = sinkShowX;
267     jsonObj[SINK_WINDOW_SHOW_Y] = srcDevId;
268     ret = sinkManager_->projectWindowListener_->ParseMessage(jsonObj.dump(),
269         srcDevId, srcWinId, sinkScreenInfo);
270     EXPECT_EQ(ERR_DH_INPUT_JSON_PARSE_FAIL, ret);
271 }
272 
273 HWTEST_F(DistributedInputSinkManagerTest, UpdateSinkScreenInfoCache_01, testing::ext::TestSize.Level1)
274 {
275     ASSERT_NE(nullptr, sinkManager_);
276     ASSERT_NE(nullptr, sinkManager_->projectWindowListener_);
277     std::string srcDevId = "umkyu1b165e1be98151891erbe8r91ev";
278     uint64_t srcWinId = 1;
279     SinkScreenInfo sinkScreenInfoTmp {2, 1860, 980, 200, 200};
280     auto ret = sinkManager_->projectWindowListener_->UpdateSinkScreenInfoCache(srcDevId, srcWinId, sinkScreenInfoTmp);
281     EXPECT_EQ(DH_SUCCESS, ret);
282 }
283 
284 HWTEST_F(DistributedInputSinkManagerTest, NotifyStopDScreen_01, testing::ext::TestSize.Level1)
285 {
286     ASSERT_NE(nullptr, sinkManager_);
287     std::string srcScreenInfoKey  = "";
288     int32_t ret = sinkManager_->NotifyStopDScreen(srcScreenInfoKey);
289     EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_SCREEN_INFO_IS_EMPTY, ret);
290 }
291 
292 HWTEST_F(DistributedInputSinkManagerTest, NotifyStopDScreen_02, testing::ext::TestSize.Level1)
293 {
294     ASSERT_NE(nullptr, sinkManager_);
295     std::string srcScreenInfoKey  = "srcScreenInfoKey_test";
296     int32_t ret = sinkManager_->NotifyStopDScreen(srcScreenInfoKey);
297     EXPECT_EQ(DH_SUCCESS, ret);
298 }
299 
300 HWTEST_F(DistributedInputSinkManagerTest, RegisterSharingDhIdListener_01, testing::ext::TestSize.Level1)
301 {
302     ASSERT_NE(nullptr, sinkManager_);
303     sptr<TestSharingDhIdListenerStub> sharingDhIdListener = new TestSharingDhIdListenerStub();
304     int32_t ret = sinkManager_->RegisterSharingDhIdListener(sharingDhIdListener);
305     EXPECT_EQ(DH_SUCCESS, ret);
306 }
307 
308 HWTEST_F(DistributedInputSinkManagerTest, Dump_01, testing::ext::TestSize.Level1)
309 {
310     ASSERT_NE(nullptr, sinkManager_);
311     int32_t fd = 1;
312     std::vector<std::u16string> args;
313     int32_t ret = sinkManager_->Dump(fd, args);
314     EXPECT_EQ(ERR_DH_INPUT_HIDUMP_DUMP_PROCESS_FAIL, ret);
315 }
316 } // namespace DistributedInput
317 } // namespace DistributedHardware
318 } // namespace OHOS