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 <gtest/gtest.h>
17 #ifdef GTEST_API_
18 #define private public
19 #define protected public
20 #endif
21
22 #include "net_manager_constants.h"
23 #include "xcollie/xcollie.h"
24 #include "xcollie/xcollie_define.h"
25 #include "netmanager_ext_test_security.h"
26 #include "networkshare_constants.h"
27 #include "networkshare_service.h"
28 #include "sharing_event_callback_stub.h"
29 #include "system_ability_definition.h"
30
31 namespace OHOS {
32 namespace NetManagerStandard {
33 namespace {
34 using namespace testing::ext;
35
36 class SharingEventTestCallback : public SharingEventCallbackStub {
37 public:
OnSharingStateChanged(const bool & isRunning)38 inline void OnSharingStateChanged(const bool &isRunning) override
39 {
40 return;
41 }
OnInterfaceSharingStateChanged(const SharingIfaceType & type,const std::string & iface,const SharingIfaceState & state)42 inline void OnInterfaceSharingStateChanged(const SharingIfaceType &type, const std::string &iface,
43 const SharingIfaceState &state) override
44 {
45 return;
46 }
OnSharingUpstreamChanged(const sptr<NetHandle> netHandle)47 inline void OnSharingUpstreamChanged(const sptr<NetHandle> netHandle) override
48 {
49 return;
50 }
51 };
52 } // namespace
53
54 class NetworkShareServiceTest : public testing::Test {
55 public:
56 static void SetUpTestCase();
57 static void TearDownTestCase();
58 void SetUp();
59 void TearDown();
60 static inline auto instance_ = DelayedSingleton<NetworkShareService>::GetInstance();
61 static inline sptr<ISharingEventCallback> eventCallback_ = nullptr;
62 };
63
SetUpTestCase()64 void NetworkShareServiceTest::SetUpTestCase()
65 {
66 instance_->OnStart();
67 eventCallback_ = new (std::nothrow) SharingEventTestCallback();
68 ASSERT_NE(eventCallback_, nullptr);
69 }
70
TearDownTestCase()71 void NetworkShareServiceTest::TearDownTestCase()
72 {
73 instance_->OnStop();
74 }
75
SetUp()76 void NetworkShareServiceTest::SetUp() {}
77
TearDown()78 void NetworkShareServiceTest::TearDown() {}
79
80 HWTEST_F(NetworkShareServiceTest, IsNetworkSharingSupportedTest001, TestSize.Level1)
81 {
82 int32_t supported;
83 auto ret = instance_->IsNetworkSharingSupported(supported);
84 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
85 }
86
87 HWTEST_F(NetworkShareServiceTest, IsNetworkSharingSupportedTest002, TestSize.Level1)
88 {
89 NetManagerExtAccessToken token;
90 int32_t supported;
91 auto ret = instance_->IsNetworkSharingSupported(supported);
92 EXPECT_EQ(supported, NETWORKSHARE_IS_UNSUPPORTED);
93 }
94
95 HWTEST_F(NetworkShareServiceTest, IsSharingTest001, TestSize.Level1)
96 {
97 int32_t sharingStatus;
98 auto ret = instance_->IsSharing(sharingStatus);
99 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
100 }
101
102 HWTEST_F(NetworkShareServiceTest, IsSharingTest002, TestSize.Level1)
103 {
104 NetManagerExtAccessToken token;
105 int32_t sharingStatus;
106 auto ret = instance_->IsSharing(sharingStatus);
107 EXPECT_NE(sharingStatus, NETWORKSHARE_IS_SHARING);
108 }
109
110 HWTEST_F(NetworkShareServiceTest, StartNetworkSharingTest001, TestSize.Level1)
111 {
112 auto ret = instance_->StartNetworkSharing(SharingIfaceType::SHARING_WIFI);
113 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
114 }
115
116 HWTEST_F(NetworkShareServiceTest, StartNetworkSharingTest002, TestSize.Level1)
117 {
118 NetManagerExtAccessToken token;
119 auto ret = instance_->StartNetworkSharing(SharingIfaceType::SHARING_WIFI);
120 int32_t sharingStatus;
121 ret = instance_->IsSharing(sharingStatus);
122 EXPECT_NE(sharingStatus, NETWORKSHARE_IS_SHARING);
123 }
124
125 HWTEST_F(NetworkShareServiceTest, StartNetworkSharingTest003, TestSize.Level1)
126 {
127 auto ret = instance_->StartNetworkSharing(SharingIfaceType::SHARING_USB);
128 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
129 }
130
131 HWTEST_F(NetworkShareServiceTest, StopNetworkSharingTest001, TestSize.Level1)
132 {
133 auto ret = instance_->StopNetworkSharing(SharingIfaceType::SHARING_WIFI);
134 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
135 }
136
137 HWTEST_F(NetworkShareServiceTest, StopNetworkSharingTest002, TestSize.Level1)
138 {
139 NetManagerExtAccessToken token;
140 auto ret = instance_->StopNetworkSharing(SharingIfaceType::SHARING_WIFI);
141 EXPECT_EQ(ret, NETWORKSHARE_ERROR_WIFI_SHARING);
142 }
143
144 HWTEST_F(NetworkShareServiceTest, StopNetworkSharingTest003, TestSize.Level1)
145 {
146 auto ret = instance_->StopNetworkSharing(SharingIfaceType::SHARING_USB);
147 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
148 }
149
150 HWTEST_F(NetworkShareServiceTest, RegisterSharingEventTest001, TestSize.Level1)
151 {
152 auto ret = instance_->RegisterSharingEvent(eventCallback_);
153 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
154 }
155
156 HWTEST_F(NetworkShareServiceTest, RegisterSharingEventTest002, TestSize.Level1)
157 {
158 NetManagerExtAccessToken token;
159 auto ret = instance_->RegisterSharingEvent(eventCallback_);
160 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
161 }
162
163 HWTEST_F(NetworkShareServiceTest, UnregisterSharingEventTest001, TestSize.Level1)
164 {
165 auto ret = instance_->UnregisterSharingEvent(eventCallback_);
166 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
167 }
168
169 HWTEST_F(NetworkShareServiceTest, UnregisterSharingEventTest002, TestSize.Level1)
170 {
171 NetManagerExtAccessToken token;
172 auto ret = instance_->UnregisterSharingEvent(eventCallback_);
173 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
174 }
175
176 HWTEST_F(NetworkShareServiceTest, GetSharableRegexsTest001, TestSize.Level1)
177 {
178 std::vector<std::string> ifaceRegexs;
179 instance_->GetSharableRegexs(SharingIfaceType::SHARING_WIFI, ifaceRegexs);
180 EXPECT_TRUE(ifaceRegexs.empty());
181 }
182
183 HWTEST_F(NetworkShareServiceTest, GetSharableRegexsTest002, TestSize.Level1)
184 {
185 NetManagerExtAccessToken token;
186 std::vector<std::string> ifaceRegexs;
187 instance_->GetSharableRegexs(SharingIfaceType::SHARING_WIFI, ifaceRegexs);
188 EXPECT_TRUE(ifaceRegexs.empty());
189 }
190
191 HWTEST_F(NetworkShareServiceTest, GetSharingStateTest001, TestSize.Level1)
192 {
193 SharingIfaceState state;
194 auto ret = instance_->GetSharingState(SharingIfaceType::SHARING_WIFI, state);
195 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
196 }
197
198 HWTEST_F(NetworkShareServiceTest, GetSharingStateTest002, TestSize.Level1)
199 {
200 NetManagerExtAccessToken token;
201 SharingIfaceState state;
202 auto ret = instance_->GetSharingState(SharingIfaceType::SHARING_WIFI, state);
203 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
204 }
205
206 HWTEST_F(NetworkShareServiceTest, GetNetSharingIfacesTest001, TestSize.Level1)
207 {
208 SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
209 std::vector<std::string> ifaceRegexs;
210 instance_->GetSharableRegexs(type, ifaceRegexs);
211 EXPECT_TRUE(ifaceRegexs.empty());
212 }
213
214 HWTEST_F(NetworkShareServiceTest, GetNetSharingIfacesTest002, TestSize.Level1)
215 {
216 NetManagerExtAccessToken token;
217 SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
218 std::vector<std::string> ifaceRegexs;
219 instance_->GetSharableRegexs(type, ifaceRegexs);
220 EXPECT_TRUE(ifaceRegexs.empty());
221 }
222
223 HWTEST_F(NetworkShareServiceTest, GetStatsRxBytesTest001, TestSize.Level1)
224 {
225 int32_t bytes;
226 auto ret = instance_->GetStatsRxBytes(bytes);
227 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
228 }
229
230 HWTEST_F(NetworkShareServiceTest, GetStatsRxBytesTest002, TestSize.Level1)
231 {
232 NetManagerExtAccessToken token;
233 int32_t bytes;
234 auto ret = instance_->GetStatsRxBytes(bytes);
235 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
236 }
237
238 HWTEST_F(NetworkShareServiceTest, GetStatsTxBytesTest001, TestSize.Level1)
239 {
240 int32_t bytes;
241 auto ret = instance_->GetStatsTxBytes(bytes);
242 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
243 }
244
245 HWTEST_F(NetworkShareServiceTest, GetStatsTxBytesTest002, TestSize.Level1)
246 {
247 NetManagerExtAccessToken token;
248 int32_t bytes;
249 auto ret = instance_->GetStatsTxBytes(bytes);
250 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
251 }
252
253 HWTEST_F(NetworkShareServiceTest, GetStatsTotalBytesTest001, TestSize.Level1)
254 {
255 int32_t bytes;
256 auto ret = instance_->GetStatsTotalBytes(bytes);
257 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
258 }
259
260 HWTEST_F(NetworkShareServiceTest, GetStatsTotalBytesTest002, TestSize.Level1)
261 {
262 NetManagerExtAccessToken token;
263 int32_t bytes;
264 auto ret = instance_->GetStatsTotalBytes(bytes);
265 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
266 }
267
268 HWTEST_F(NetworkShareServiceTest, SetConfigureForShareTest001, TestSize.Level1)
269 {
270 bool enabled = true;
271 auto ret = instance_->SetConfigureForShare(enabled);
272 EXPECT_NE(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
273 }
274
275 HWTEST_F(NetworkShareServiceTest, SetConfigureForShareTest002, TestSize.Level1)
276 {
277 NetManagerExtAccessToken token;
278 bool enabled = true;
279 auto ret = instance_->SetConfigureForShare(enabled);
280 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
281 }
282
283 HWTEST_F(NetworkShareServiceTest, SetConfigureForShareTest003, TestSize.Level1)
284 {
285 NetManagerExtAccessToken token;
286 bool enabled = false;
287 auto ret = instance_->SetConfigureForShare(enabled);
288 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
289 }
290
291 HWTEST_F(NetworkShareServiceTest, GetDumpMessage001, TestSize.Level1)
292 {
293 NetManagerExtAccessToken token;
294 std::string message = "";
295 instance_->GetDumpMessage(message);
296 EXPECT_TRUE(!message.empty());
297 }
298
299 HWTEST_F(NetworkShareServiceTest, GetShareRegexsContent001, TestSize.Level1)
300 {
301 std::string shareRegexsContent = "";
302 SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
303 instance_->GetShareRegexsContent(type, shareRegexsContent);
304 EXPECT_TRUE(shareRegexsContent.empty());
305 }
306
307 HWTEST_F(NetworkShareServiceTest, NetworkShareServiceBranch001, TestSize.Level1)
308 {
309 instance_->state_ = NetworkShareService::ServiceRunningState::STATE_RUNNING;
310 instance_->OnStart();
311
312 std::vector<std::u16string> args;
313 args.emplace_back(u"test data");
314 int32_t fd = 0;
315 int32_t ret = instance_->Dump(fd, args);
316 EXPECT_EQ(ret, NETWORKSHARE_ERROR_INTERNAL_ERROR);
317
318 std::string sharingType;
319 std::string typeContent = "wifi;";
320 instance_->GetSharingType(SharingIfaceType::SHARING_BLUETOOTH, typeContent, sharingType);
321
322 SharingIfaceState state = SharingIfaceState::SHARING_NIC_CAN_SERVER;
323 std::vector<std::string> ifaces;
324 ret = instance_->GetNetSharingIfaces(state, ifaces);
325 EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
326 }
327
328 HWTEST_F(NetworkShareServiceTest, NetworkShareServiceBranch002, TestSize.Level1)
329 {
330 NetManagerExtAccessToken token;
331 SharingIfaceState state = SharingIfaceState::SHARING_NIC_CAN_SERVER;
332 std::vector<std::string> ifaces;
333 int32_t ret = instance_->GetNetSharingIfaces(state, ifaces);
334 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
335 }
336
337 HWTEST_F(NetworkShareServiceTest, OnAddSystemAbility001, TestSize.Level1)
338 {
339 std::string deviceId = "dev1";
340 instance_->OnRemoveSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
341 EXPECT_TRUE(instance_->hasSARemoved_);
342
343 instance_->OnAddSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
344 EXPECT_FALSE(instance_->hasSARemoved_);
345 }
346 } // namespace NetManagerStandard
347 } // namespace OHOS
348