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 #include "sharing_event_callback_stub.h"
22 #include "networkshare_tracker.h"
23 #ifdef BLUETOOTH_MODOULE
24 #include "bluetooth_pan.h"
25 #include "bluetooth_remote_device.h"
26 #endif
27 
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
31 using namespace testing::ext;
32 static constexpr const char *WIFI_AP_DEFAULT_IFACE_NAME = "wlan0";
33 static constexpr const char *USB_AP_DEFAULT_IFACE_NAME = "usb0";
34 static constexpr const char *USB_AP_RNDIS_IFACE_NAME = "rndis0";
35 static constexpr const char *BLUETOOTH_DEFAULT_IFACE_NAME = "bt-pan";
36 static constexpr const char *TEST_IFACE_NAME = "testIface";
37 static constexpr int32_t MAX_CALLBACK_COUNT = 100;
38 std::map<int32_t, sptr<ISharingEventCallback>> g_callbackMap;
39 
40 class SharingEventTestCallback : public SharingEventCallbackStub {
41 public:
OnSharingStateChanged(const bool & isRunning)42     inline void OnSharingStateChanged(const bool &isRunning) override
43     {
44         return;
45     }
OnInterfaceSharingStateChanged(const SharingIfaceType & type,const std::string & iface,const SharingIfaceState & state)46     inline void OnInterfaceSharingStateChanged(const SharingIfaceType &type, const std::string &iface,
47                                                const SharingIfaceState &state) override
48     {
49         return;
50     }
OnSharingUpstreamChanged(const sptr<NetHandle> netHandle)51     inline void OnSharingUpstreamChanged(const sptr<NetHandle> netHandle) override
52     {
53         return;
54     }
55 };
56 } // namespace
57 
58 class NetworkShareTrackerTest : public testing::Test {
59 public:
60     static void SetUpTestCase();
61     static void TearDownTestCase();
62     void SetUp();
63     void TearDown();
64     static inline sptr<ISharingEventCallback> callback_ = nullptr;
65     static inline std::shared_ptr<NetworkShareTracker> instance_ = nullptr;
66 };
67 
SetUpTestCase()68 void NetworkShareTrackerTest::SetUpTestCase() {}
69 
TearDownTestCase()70 void NetworkShareTrackerTest::TearDownTestCase() {}
71 
SetUp()72 void NetworkShareTrackerTest::SetUp()
73 {
74     instance_ = DelayedSingleton<NetworkShareTracker>::GetInstance();
75 }
76 
TearDown()77 void NetworkShareTrackerTest::TearDown()
78 {
79     NetworkShareTracker::GetInstance().Uninit();
80 }
81 
82 HWTEST_F(NetworkShareTrackerTest, IsNetworkSharingSupported00, TestSize.Level1)
83 {
84     int32_t supported;
85     auto nret = NetworkShareTracker::GetInstance().IsNetworkSharingSupported(supported);
86     EXPECT_EQ(nret, NETWORKSHARE_ERROR_IFACE_CFG_ERROR);
87 }
88 
89 HWTEST_F(NetworkShareTrackerTest, GetSharableRegexs00, TestSize.Level1)
90 {
91     SharingIfaceType type = SharingIfaceType::SHARING_BLUETOOTH;
92     std::vector<std::string> ret;
93     auto nret = NetworkShareTracker::GetInstance().GetSharableRegexs(type, ret);
94     EXPECT_EQ(nret, NETWORKSHARE_ERROR_IFACE_CFG_ERROR);
95 }
96 
97 HWTEST_F(NetworkShareTrackerTest, SetUpstreamNetHandle00, TestSize.Level1)
98 {
99     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle();
100     sptr<NetAllCapabilities> netcap = nullptr;
101     sptr<NetLinkInfo> netlinkinfo = nullptr;
102     std::shared_ptr<UpstreamNetworkInfo> netinfo =
103         std::make_shared<UpstreamNetworkInfo>(netHandle, netcap, netlinkinfo);
104     NetworkShareTracker::GetInstance().SetUpstreamNetHandle(netinfo);
105     EXPECT_EQ(NetworkShareTracker::GetInstance().mainStateMachine_, nullptr);
106 }
107 
108 HWTEST_F(NetworkShareTrackerTest, SendMainSMEvent00, TestSize.Level1)
109 {
110     auto configuration = std::make_shared<NetworkShareConfiguration>();
111     auto subSM = std::make_shared<NetworkShareSubStateMachine>(WIFI_AP_DEFAULT_IFACE_NAME,
112                                                                SharingIfaceType::SHARING_WIFI, configuration);
113 
114     NetworkShareTracker::GetInstance().SendMainSMEvent(subSM, 0, 0);
115     EXPECT_EQ(NetworkShareTracker::GetInstance().mainStateMachine_, nullptr);
116 }
117 
118 HWTEST_F(NetworkShareTrackerTest, IsInterfaceMatchType00, TestSize.Level1)
119 {
120     auto ret = NetworkShareTracker::GetInstance().IsInterfaceMatchType(WIFI_AP_DEFAULT_IFACE_NAME,
121                                                                        SharingIfaceType::SHARING_WIFI);
122     EXPECT_FALSE(ret);
123 }
124 
125 HWTEST_F(NetworkShareTrackerTest, InterfaceNameToType00, TestSize.Level1)
126 {
127     std::string iface = TEST_IFACE_NAME;
128     SharingIfaceType interfaceType;
129 
130     NetworkShareTracker::GetInstance().InterfaceStatusChanged(TEST_IFACE_NAME, false);
131     NetworkShareTracker::GetInstance().InterfaceAdded(TEST_IFACE_NAME);
132     NetworkShareTracker::GetInstance().InterfaceRemoved(TEST_IFACE_NAME);
133     auto ret = NetworkShareTracker::GetInstance().InterfaceNameToType(iface, interfaceType);
134     EXPECT_FALSE(ret);
135 }
136 
137 /**
138  * @tc.name: Init01
139  * @tc.desc: Test NetworkShareTracker Init.
140  * @tc.type: FUNC
141  */
142 HWTEST_F(NetworkShareTrackerTest, Init01, TestSize.Level1)
143 {
144     bool ret = NetworkShareTracker::GetInstance().Init();
145     EXPECT_EQ(ret, true);
146 }
147 
148 /**
149  * @tc.name: IsNetworkSharingSupported01
150  * @tc.desc: Test NetworkShareTracker IsNetworkSharingSupported.
151  * @tc.type: FUNC
152  */
153 HWTEST_F(NetworkShareTrackerTest, IsNetworkSharingSupported01, TestSize.Level1)
154 {
155     int32_t supported;
156     NetworkShareTracker::GetInstance().IsNetworkSharingSupported(supported);
157     EXPECT_EQ(supported, NETWORKSHARE_IS_SUPPORTED);
158 }
159 
160 /**
161  * @tc.name: IsSharing01
162  * @tc.desc: Test NetworkShareTracker IsSharing.
163  * @tc.type: FUNC
164  */
165 HWTEST_F(NetworkShareTrackerTest, IsSharing01, TestSize.Level1)
166 {
167     int32_t sharingStatus;
168     NetworkShareTracker::GetInstance().IsSharing(sharingStatus);
169     EXPECT_EQ(sharingStatus, NETWORKSHARE_IS_UNSHARING);
170 }
171 
172 /**
173  * @tc.name: StartNetworkSharing01
174  * @tc.desc: Test NetworkShareTracker StartNetworkSharing.
175  * @tc.type: FUNC
176  */
177 HWTEST_F(NetworkShareTrackerTest, StartNetworkSharing01, TestSize.Level1)
178 {
179     SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
180     int32_t ret = NetworkShareTracker::GetInstance().StartNetworkSharing(type);
181     EXPECT_EQ(ret, NETWORKSHARE_ERROR_WIFI_SHARING);
182 
183     ret = NetworkShareTracker::GetInstance().StartNetworkSharing(type);
184     EXPECT_EQ(ret, NETWORKSHARE_ERROR_WIFI_SHARING);
185 
186     type = SharingIfaceType::SHARING_USB;
187     ret = NetworkShareTracker::GetInstance().StartNetworkSharing(type);
188     EXPECT_EQ(ret, NETWORKSHARE_ERROR_USB_SHARING);
189 
190     type = SharingIfaceType::SHARING_BLUETOOTH;
191     ret = NetworkShareTracker::GetInstance().StartNetworkSharing(type);
192     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
193 }
194 
195 /**
196  * @tc.name: StopNetworkSharing01
197  * @tc.desc: Test NetworkShareTracker StopNetworkSharing.
198  * @tc.type: FUNC
199  */
200 HWTEST_F(NetworkShareTrackerTest, StopNetworkSharing01, TestSize.Level1)
201 {
202     SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
203     int32_t ret = NetworkShareTracker::GetInstance().StopNetworkSharing(type);
204     EXPECT_EQ(ret, NETWORKSHARE_ERROR_WIFI_SHARING);
205 
206     type = SharingIfaceType::SHARING_USB;
207     ret = NetworkShareTracker::GetInstance().StopNetworkSharing(type);
208     EXPECT_EQ(ret, NETWORKSHARE_ERROR_USB_SHARING);
209 
210     type = SharingIfaceType::SHARING_BLUETOOTH;
211     ret = NetworkShareTracker::GetInstance().StopNetworkSharing(type);
212     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
213 }
214 
215 /**
216  * @tc.name: GetSharableRegexs01
217  * @tc.desc: Test NetworkShareTracker GetSharableRegexs.
218  * @tc.type: FUNC
219  */
220 HWTEST_F(NetworkShareTrackerTest, GetSharableRegexs01, TestSize.Level1)
221 {
222     SharingIfaceType type = SharingIfaceType::SHARING_BLUETOOTH;
223     std::vector<std::string> ret;
224     auto nret = NetworkShareTracker::GetInstance().GetSharableRegexs(type, ret);
225     EXPECT_EQ(nret, NETMANAGER_EXT_SUCCESS);
226 
227     type = SharingIfaceType::SHARING_USB;
228     nret = NetworkShareTracker::GetInstance().GetSharableRegexs(type, ret);
229     EXPECT_EQ(nret, NETMANAGER_EXT_SUCCESS);
230 
231     type = SharingIfaceType::SHARING_WIFI;
232     nret = NetworkShareTracker::GetInstance().GetSharableRegexs(type, ret);
233     EXPECT_EQ(nret, NETMANAGER_EXT_SUCCESS);
234 }
235 
236 /**
237  * @tc.name: GetSharingState01
238  * @tc.desc: Test NetworkShareTracker GetSharingState.
239  * @tc.type: FUNC
240  */
241 HWTEST_F(NetworkShareTrackerTest, GetSharingState01, TestSize.Level1)
242 {
243     SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
244     SharingIfaceState state = SharingIfaceState::SHARING_NIC_SERVING;
245 
246     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
247     NetworkShareTracker::GetInstance().subStateMachineMap_.insert(
248         std::make_pair(BLUETOOTH_DEFAULT_IFACE_NAME, nullptr));
249     NetworkShareTracker::GetInstance().subStateMachineMap_.insert(
250         std::make_pair(WIFI_AP_DEFAULT_IFACE_NAME, nullptr));
251 
252     int32_t ret = NetworkShareTracker::GetInstance().GetSharingState(type, state);
253     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
254     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
255     EXPECT_EQ(state, SharingIfaceState::SHARING_NIC_CAN_SERVER);
256 }
257 
258 /**
259  * @tc.name: GetSharingState02
260  * @tc.desc: Test NetworkShareTracker GetSharingState.
261  * @tc.type: FUNC
262  */
263 HWTEST_F(NetworkShareTrackerTest, GetSharingState02, TestSize.Level1)
264 {
265     SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
266     SharingIfaceState state = SharingIfaceState::SHARING_NIC_SERVING;
267     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
268     NetworkShareTracker::GetInstance().CreateSubStateMachine(WIFI_AP_DEFAULT_IFACE_NAME, type, false);
269     auto itfind = NetworkShareTracker::GetInstance().subStateMachineMap_.find(WIFI_AP_DEFAULT_IFACE_NAME);
270     ASSERT_NE(itfind, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
271     itfind->second->lastState_ = SUB_SM_STATE_UNAVAILABLE;
272 
273     int32_t ret = NetworkShareTracker::GetInstance().GetSharingState(type, state);
274     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
275     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
276     EXPECT_EQ(state, SharingIfaceState::SHARING_NIC_ERROR);
277 
278     type = SharingIfaceType::SHARING_USB;
279     NetworkShareTracker::GetInstance().CreateSubStateMachine(USB_AP_DEFAULT_IFACE_NAME, type, false);
280     itfind = NetworkShareTracker::GetInstance().subStateMachineMap_.find(USB_AP_DEFAULT_IFACE_NAME);
281     ASSERT_NE(itfind, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
282     itfind->second->lastState_ = SUB_SM_STATE_AVAILABLE;
283 
284     ret = NetworkShareTracker::GetInstance().GetSharingState(type, state);
285     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
286     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
287     EXPECT_EQ(state, SharingIfaceState::SHARING_NIC_CAN_SERVER);
288 
289     type = SharingIfaceType::SHARING_BLUETOOTH;
290     NetworkShareTracker::GetInstance().CreateSubStateMachine(BLUETOOTH_DEFAULT_IFACE_NAME, type, false);
291     itfind = NetworkShareTracker::GetInstance().subStateMachineMap_.find(BLUETOOTH_DEFAULT_IFACE_NAME);
292     ASSERT_NE(itfind, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
293     itfind->second->lastState_ = SUB_SM_STATE_SHARED;
294 
295     ret = NetworkShareTracker::GetInstance().GetSharingState(type, state);
296     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
297     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
298     EXPECT_EQ(state, SharingIfaceState::SHARING_NIC_SERVING);
299 }
300 
301 /**
302  * @tc.name: GetSharingState03
303  * @tc.desc: Test NetworkShareTracker GetSharingState.
304  * @tc.type: FUNC
305  */
306 HWTEST_F(NetworkShareTrackerTest, GetSharingState03, TestSize.Level1)
307 {
308     SharingIfaceType type = static_cast<SharingIfaceType>(3);
309     SharingIfaceState state = SharingIfaceState::SHARING_NIC_SERVING;
310     int32_t ret = NetworkShareTracker::GetInstance().GetSharingState(type, state);
311     EXPECT_EQ(ret, NETWORKSHARE_ERROR_UNKNOWN_TYPE);
312 }
313 
314 /**
315  * @tc.name: GetNetSharingIfaces01
316  * @tc.desc: Test NetworkShareTracker GetNetSharingIfaces.
317  * @tc.type: FUNC
318  */
319 HWTEST_F(NetworkShareTrackerTest, GetNetSharingIfaces01, TestSize.Level1)
320 {
321     SharingIfaceType type = SharingIfaceType::SHARING_WIFI;
322     SharingIfaceState state = SharingIfaceState::SHARING_NIC_ERROR;
323     std::vector<std::string> ifaces;
324     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
325     NetworkShareTracker::GetInstance().subStateMachineMap_.insert(
326         std::make_pair(BLUETOOTH_DEFAULT_IFACE_NAME, nullptr));
327 
328     NetworkShareTracker::GetInstance().GetNetSharingIfaces(state, ifaces);
329     EXPECT_EQ(ifaces.size(), 0);
330 
331     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
332     NetworkShareTracker::GetInstance().CreateSubStateMachine(WIFI_AP_DEFAULT_IFACE_NAME, type, false);
333     auto itfind = NetworkShareTracker::GetInstance().subStateMachineMap_.find(WIFI_AP_DEFAULT_IFACE_NAME);
334     ASSERT_NE(itfind, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
335     itfind->second->lastState_ = SUB_SM_STATE_UNAVAILABLE;
336     NetworkShareTracker::GetInstance().GetNetSharingIfaces(state, ifaces);
337     NetworkShareTracker::GetInstance().subStateMachineMap_.clear();
338     EXPECT_EQ(ifaces.at(0), WIFI_AP_DEFAULT_IFACE_NAME);
339 }
340 
341 /**
342  * @tc.name: GetNetSharingIfaces02
343  * @tc.desc: Test NetworkShareTracker GetNetSharingIfaces.
344  * @tc.type: FUNC
345  */
346 HWTEST_F(NetworkShareTrackerTest, GetNetSharingIfaces02, TestSize.Level1)
347 {
348     SharingIfaceState state = static_cast<SharingIfaceState>(4);
349     std::vector<std::string> ifaces;
350     int32_t ret = NetworkShareTracker::GetInstance().GetNetSharingIfaces(state, ifaces);
351     EXPECT_EQ(ret, NETWORKSHARE_ERROR_UNKNOWN_TYPE);
352 }
353 
354 /**
355  * @tc.name: RegisterSharingEvent01
356  * @tc.desc: Test NetworkShareTracker RegisterSharingEvent.
357  * @tc.type: FUNC
358  */
359 HWTEST_F(NetworkShareTrackerTest, RegisterSharingEvent01, TestSize.Level1)
360 {
361     sptr<ISharingEventCallback> callback = nullptr;
362     int32_t ret = NetworkShareTracker::GetInstance().RegisterSharingEvent(callback);
363     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_LOCAL_PTR_NULL);
364 }
365 
366 /**
367  * @tc.name: RegisterSharingEvent02
368  * @tc.desc: Test NetworkShareTracker RegisterSharingEvent.
369  * @tc.type: FUNC
370  */
371 HWTEST_F(NetworkShareTrackerTest, RegisterSharingEvent02, TestSize.Level1)
372 {
373     for (int32_t i = 0; i < MAX_CALLBACK_COUNT; i++) {
374         g_callbackMap[i] = new (std::nothrow) SharingEventTestCallback();
375     }
376 
__anonef1eb6ef0202(const auto &pair) 377     std::for_each(g_callbackMap.begin(), g_callbackMap.end(), [this](const auto &pair) {
378         NetworkShareTracker::GetInstance().RegisterSharingEvent(pair.second);
379         });
380     sptr<ISharingEventCallback> callback = new (std::nothrow) SharingEventTestCallback();
381     int32_t ret = NetworkShareTracker::GetInstance().RegisterSharingEvent(callback);
382     EXPECT_EQ(ret, NETWORKSHARE_ERROR_ISSHARING_CALLBACK_ERROR);
__anonef1eb6ef0302(const auto &pair) 383     std::for_each(g_callbackMap.begin(), g_callbackMap.end(), [this](const auto &pair) {
384         NetworkShareTracker::GetInstance().UnregisterSharingEvent(pair.second);
385         });
386     NetworkShareTracker::GetInstance().UnregisterSharingEvent(callback);
387     EXPECT_EQ(NetworkShareTracker::GetInstance().sharingEventCallback_.size(), 0);
388 }
389 
390 /**
391  * @tc.name: UpstreamWanted01
392  * @tc.desc: Test NetworkShareTracker UpstreamWanted.
393  * @tc.type: FUNC
394  */
395 HWTEST_F(NetworkShareTrackerTest, UpstreamWanted01, TestSize.Level1)
396 {
397     bool ret = NetworkShareTracker::GetInstance().UpstreamWanted();
398     EXPECT_TRUE(ret);
399 }
400 
401 /**
402  * @tc.name: ModifySharedSubStateMachineList01
403  * @tc.desc: Test NetworkShareTracker ModifySharedSubStateMachineList.
404  * @tc.type: FUNC
405  */
406 HWTEST_F(NetworkShareTrackerTest, ModifySharedSubStateMachineList01, TestSize.Level1)
407 {
408     auto configuration = std::make_shared<NetworkShareConfiguration>();
409     std::shared_ptr<NetworkShareSubStateMachine> subSm = std::make_shared<NetworkShareSubStateMachine>(
410         WIFI_AP_DEFAULT_IFACE_NAME, SharingIfaceType::SHARING_WIFI, configuration);
411     auto oldsize = NetworkShareTracker::GetInstance().sharedSubSM_.size();
412     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(true, subSm);
413     auto subsm2 = std::make_shared<NetworkShareSubStateMachine>(
414         BLUETOOTH_DEFAULT_IFACE_NAME, SharingIfaceType::SHARING_BLUETOOTH, configuration);
415     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(true, subsm2);
416     EXPECT_EQ(NetworkShareTracker::GetInstance().sharedSubSM_.size(), oldsize + 2);
417 
418     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(false, subsm2);
419     EXPECT_EQ(NetworkShareTracker::GetInstance().sharedSubSM_.size(), oldsize + 1);
420 }
421 
422 /**
423  * @tc.name: GetMainStateMachine01
424  * @tc.desc: Test NetworkShareTracker GetMainStateMachine.
425  * @tc.type: FUNC
426  */
427 HWTEST_F(NetworkShareTrackerTest, GetMainStateMachine01, TestSize.Level1)
428 {
429     std::shared_ptr<NetworkShareMainStateMachine> mainStateMachine =
430         NetworkShareTracker::GetInstance().GetMainStateMachine();
431     EXPECT_NE(mainStateMachine, nullptr);
432 }
433 
434 /**
435  * @tc.name: SetUpstreamNetHandle01
436  * @tc.desc: Test NetworkShareTracker SetUpstreamNetHandle.
437  * @tc.type: FUNC
438  */
439 HWTEST_F(NetworkShareTrackerTest, SetUpstreamNetHandle01, TestSize.Level1)
440 {
441     std::shared_ptr<UpstreamNetworkInfo> netinfo = nullptr;
442     NetworkShareTracker::GetInstance().SetUpstreamNetHandle(netinfo);
443     EXPECT_EQ(netinfo, nullptr);
444 }
445 
446 /**
447  * @tc.name: SetUpstreamNetHandle02
448  * @tc.desc: Test NetworkShareTracker SetUpstreamNetHandle.
449  * @tc.type: FUNC
450  */
451 HWTEST_F(NetworkShareTrackerTest, SetUpstreamNetHandle02, TestSize.Level1)
452 {
453     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle(-1);
454     sptr<NetAllCapabilities> netcap = nullptr;
455     sptr<NetLinkInfo> netlinkinfo = nullptr;
456     std::shared_ptr<UpstreamNetworkInfo> netinfo =
457         std::make_shared<UpstreamNetworkInfo>(netHandle, netcap, netlinkinfo);
458     NetworkShareTracker::GetInstance().SetUpstreamNetHandle(netinfo);
459     EXPECT_EQ(NetworkShareTracker::GetInstance().mainStateMachine_->errorType_, CMD_SET_DNS_FORWARDERS_ERROR);
460 }
461 
462 /**
463  * @tc.name: SetUpstreamNetHandle03
464  * @tc.desc: Test NetworkShareTracker SetUpstreamNetHandle.
465  * @tc.type: FUNC
466  */
467 HWTEST_F(NetworkShareTrackerTest, SetUpstreamNetHandle03, TestSize.Level1)
468 {
469     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle();
470     sptr<NetAllCapabilities> netcap = nullptr;
471     sptr<NetLinkInfo> netlinkinfo = nullptr;
472     std::shared_ptr<UpstreamNetworkInfo> netinfo =
473         std::make_shared<UpstreamNetworkInfo>(netHandle, netcap, netlinkinfo);
474     NetworkShareTracker::GetInstance().mainStateMachine_->SwitcheToErrorState(NETWORKSHARING_SHARING_NO_ERROR);
475     NetworkShareTracker::GetInstance().SetUpstreamNetHandle(netinfo);
476     EXPECT_EQ(NetworkShareTracker::GetInstance().mainStateMachine_->errorType_, NETWORKSHARING_SHARING_NO_ERROR);
477 }
478 
479 /**
480  * @tc.name: GetUpstreamInfo01
481  * @tc.desc: Test NetworkShareTracker GetUpstreamInfo.
482  * @tc.type: FUNC
483  */
484 HWTEST_F(NetworkShareTrackerTest, GetUpstreamInfo01, TestSize.Level1)
485 {
486     std::shared_ptr<UpstreamNetworkInfo> upstreamInfo = nullptr;
487 
488     NetworkShareTracker::GetInstance().GetUpstreamInfo(upstreamInfo);
489     EXPECT_NE(upstreamInfo, nullptr);
490 }
491 
492 /**
493  * @tc.name: NotifyDownstreamsHasNewUpstreamIface01
494  * @tc.desc: Test NetworkShareTracker NotifyDownstreamsHasNewUpstreamIface.
495  * @tc.type: FUNC
496  */
497 HWTEST_F(NetworkShareTrackerTest, NotifyDownstreamsHasNewUpstreamIface01, TestSize.Level1)
498 {
499     sptr<NetHandle> netHandle = nullptr;
500     sptr<NetAllCapabilities> netcap = nullptr;
501     sptr<NetLinkInfo> netlinkinfo = nullptr;
502     std::shared_ptr<UpstreamNetworkInfo> netinfo =
503         std::make_shared<UpstreamNetworkInfo>(netHandle, netcap, netlinkinfo);
504 
505     NetworkShareTracker::GetInstance().NotifyDownstreamsHasNewUpstreamIface(netinfo);
506     EXPECT_EQ(NetworkShareTracker::GetInstance().upstreamInfo_.get(), netinfo.get());
507 }
508 
509 /**
510  * @tc.name: GetSharedSubSMTraffic01
511  * @tc.desc: Test NetworkShareTracker GetSharedSubSMTraffic.
512  * @tc.type: FUNC
513  */
514 HWTEST_F(NetworkShareTrackerTest, GetSharedSubSMTraffic01, TestSize.Level1)
515 {
516     TrafficType type = TrafficType::TRAFFIC_ALL;
517     int32_t kbByte;
518     NetworkShareTracker::GetInstance().GetSharedSubSMTraffic(type, kbByte);
519     EXPECT_GE(kbByte, 0);
520 }
521 
522 /**
523  * @tc.name: GetSharedSubSMTraffic02
524  * @tc.desc: Test NetworkShareTracker GetSharedSubSMTraffic.
525  * @tc.type: FUNC
526  */
527 HWTEST_F(NetworkShareTrackerTest, GetSharedSubSMTraffic02, TestSize.Level1)
528 {
529     TrafficType type = TrafficType::TRAFFIC_RX;
530     int32_t kbByte;
531     NetworkShareTracker::GetInstance().GetSharedSubSMTraffic(type, kbByte);
532     EXPECT_GE(kbByte, 0);
533 }
534 
535 /**
536  * @tc.name: GetSharedSubSMTraffic03
537  * @tc.desc: Test NetworkShareTracker GetSharedSubSMTraffic.
538  * @tc.type: FUNC
539  */
540 HWTEST_F(NetworkShareTrackerTest, GetSharedSubSMTraffic03, TestSize.Level1)
541 {
542     TrafficType type = TrafficType::TRAFFIC_TX;
543     int32_t kbByte;
544     NetworkShareTracker::GetInstance().GetSharedSubSMTraffic(type, kbByte);
545     EXPECT_GE(kbByte, 0);
546 }
547 
548 #ifdef WIFI_MODOULE
549 HWTEST_F(NetworkShareTrackerTest, OnWifiHotspotStateChanged01, TestSize.Level1)
550 {
551     int32_t state = 2;
552     NetworkShareTracker::GetInstance().OnWifiHotspotStateChanged(state);
553     EXPECT_EQ(NetworkShareTracker::GetInstance().curWifiState_, Wifi::ApState::AP_STATE_STARTING);
554 
555     state = 3;
556     NetworkShareTracker::GetInstance().OnWifiHotspotStateChanged(state);
557     EXPECT_EQ(NetworkShareTracker::GetInstance().curWifiState_, Wifi::ApState::AP_STATE_STARTED);
558 
559     state = 4;
560     NetworkShareTracker::GetInstance().OnWifiHotspotStateChanged(state);
561     EXPECT_EQ(NetworkShareTracker::GetInstance().curWifiState_, Wifi::ApState::AP_STATE_CLOSING);
562 
563     state = 5;
564     NetworkShareTracker::GetInstance().OnWifiHotspotStateChanged(state);
565     EXPECT_EQ(NetworkShareTracker::GetInstance().curWifiState_, Wifi::ApState::AP_STATE_CLOSED);
566 
567     state = 0;
568     NetworkShareTracker::GetInstance().OnWifiHotspotStateChanged(state);
569     EXPECT_EQ(NetworkShareTracker::GetInstance().curWifiState_, Wifi::ApState::AP_STATE_NONE);
570 }
571 #endif
572 
573 HWTEST_F(NetworkShareTrackerTest, EnableNetSharingInternal01, TestSize.Level1)
574 {
575     SharingIfaceType type = static_cast<SharingIfaceType>(3);
576     auto ret = NetworkShareTracker::GetInstance().EnableNetSharingInternal(type, false);
577     EXPECT_EQ(ret, NETWORKSHARE_ERROR_UNKNOWN_TYPE);
578 }
579 
580 HWTEST_F(NetworkShareTrackerTest, Sharing01, TestSize.Level1)
581 {
582     std::string iface = "testIface";
583     int32_t reqState = 0;
584     int32_t ret = NetworkShareTracker::GetInstance().Sharing(iface, reqState);
585     EXPECT_EQ(NETWORKSHARE_ERROR_UNKNOWN_IFACE, ret);
586 }
587 
588 HWTEST_F(NetworkShareTrackerTest, EnableWifiSubStateMachine01, TestSize.Level1)
589 {
590     NetworkShareTracker::GetInstance().subStateMachineMap_.insert(
591         std::make_pair(BLUETOOTH_DEFAULT_IFACE_NAME, nullptr));
592     NetworkShareTracker::GetInstance().subStateMachineMap_.insert(
593         std::make_pair(WIFI_AP_DEFAULT_IFACE_NAME, nullptr));
594     NetworkShareTracker::GetInstance().EnableWifiSubStateMachine();
595     auto iter = NetworkShareTracker::GetInstance().subStateMachineMap_.find(WIFI_AP_DEFAULT_IFACE_NAME);
596     EXPECT_NE(iter, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
597 }
598 
599 HWTEST_F(NetworkShareTrackerTest, EnableBluetoothSubStateMachine01, TestSize.Level1)
600 {
601     NetworkShareTracker::GetInstance().EnableBluetoothSubStateMachine();
602     auto iter = NetworkShareTracker::GetInstance().subStateMachineMap_.find(BLUETOOTH_DEFAULT_IFACE_NAME);
603     EXPECT_NE(iter, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
604 }
605 
606 HWTEST_F(NetworkShareTrackerTest, StopDnsProxy01, TestSize.Level1)
607 {
608     NetworkShareTracker::GetInstance().isStartDnsProxy_ = true;
609     NetworkShareTracker::GetInstance().StopDnsProxy();
610     EXPECT_FALSE(NetworkShareTracker::GetInstance().isStartDnsProxy_);
611 }
612 
613 HWTEST_F(NetworkShareTrackerTest, StopSubStateMachine01, TestSize.Level1)
614 {
615     std::string iface = TEST_IFACE_NAME;
616     SharingIfaceType interfaceType = static_cast<SharingIfaceType>(3);
617     NetworkShareTracker::GetInstance().StopSubStateMachine(iface, interfaceType);
618     auto itfind = NetworkShareTracker::GetInstance().subStateMachineMap_.find(TEST_IFACE_NAME);
619     EXPECT_EQ(itfind, NetworkShareTracker::GetInstance().subStateMachineMap_.end());
620 }
621 
622 HWTEST_F(NetworkShareTrackerTest, InterfaceNameToType01, TestSize.Level1)
623 {
624     std::string iface = TEST_IFACE_NAME;
625     SharingIfaceType interfaceType;
626     auto ret = NetworkShareTracker::GetInstance().InterfaceNameToType(iface, interfaceType);
627     EXPECT_FALSE(ret);
628 
629     iface = WIFI_AP_DEFAULT_IFACE_NAME;
630     NetworkShareTracker::GetInstance().InterfaceNameToType(iface, interfaceType);
631     EXPECT_EQ(interfaceType, SharingIfaceType::SHARING_WIFI);
632 
633     iface = USB_AP_DEFAULT_IFACE_NAME;
634     NetworkShareTracker::GetInstance().InterfaceNameToType(iface, interfaceType);
635     EXPECT_EQ(interfaceType, SharingIfaceType::SHARING_USB);
636 
637     iface = BLUETOOTH_DEFAULT_IFACE_NAME;
638     NetworkShareTracker::GetInstance().InterfaceNameToType(iface, interfaceType);
639     EXPECT_EQ(interfaceType, SharingIfaceType::SHARING_BLUETOOTH);
640 }
641 
642 HWTEST_F(NetworkShareTrackerTest, IsHandleNetlinkEvent01, TestSize.Level1)
643 {
644     SharingIfaceType type;
645     bool ret = false;
646 #ifdef WIFI_MODOULE
647     type = SharingIfaceType::SHARING_WIFI;
648     NetworkShareTracker::GetInstance().curWifiState_ = Wifi::ApState::AP_STATE_CLOSING;
649     ret = NetworkShareTracker::GetInstance().IsHandleNetlinkEvent(type, false);
650     EXPECT_TRUE(ret);
651 #endif
652 #ifdef USB_MODOULE
653     type = SharingIfaceType::SHARING_USB;
654     NetworkShareTracker::GetInstance().curUsbState_ = UsbShareState::USB_CLOSING;
655     ret = NetworkShareTracker::GetInstance().IsHandleNetlinkEvent(type, false);
656     EXPECT_TRUE(ret);
657 #endif
658     NetworkShareTracker::GetInstance().InterfaceStatusChanged(TEST_IFACE_NAME, false);
659     NetworkShareTracker::GetInstance().InterfaceStatusChanged(WIFI_AP_DEFAULT_IFACE_NAME, false);
660 #ifdef WIFI_MODOULE
661     NetworkShareTracker::GetInstance().curWifiState_ = Wifi::ApState::AP_STATE_STARTING;
662 #endif
663     NetworkShareTracker::GetInstance().InterfaceStatusChanged(WIFI_AP_DEFAULT_IFACE_NAME, true);
664     NetworkShareTracker::GetInstance().InterfaceStatusChanged(USB_AP_RNDIS_IFACE_NAME, true);
665 
666     NetworkShareTracker::GetInstance().InterfaceAdded(TEST_IFACE_NAME);
667     NetworkShareTracker::GetInstance().InterfaceAdded(WIFI_AP_DEFAULT_IFACE_NAME);
668 
669     NetworkShareTracker::GetInstance().InterfaceRemoved(TEST_IFACE_NAME);
670     NetworkShareTracker::GetInstance().InterfaceAdded(WIFI_AP_DEFAULT_IFACE_NAME);
671 
672 #ifdef BLUETOOTH_MODOULE
673     type = SharingIfaceType::SHARING_BLUETOOTH;
674     NetworkShareTracker::GetInstance().curBluetoothState_ = Bluetooth::BTConnectState::CONNECTING;
675     ret = NetworkShareTracker::GetInstance().IsHandleNetlinkEvent(type, true);
676     EXPECT_TRUE(ret);
677 #endif
678 
679     type = static_cast<SharingIfaceType>(3);
680     ret = NetworkShareTracker::GetInstance().IsHandleNetlinkEvent(type, false);
681     EXPECT_FALSE(ret);
682 }
683 
684 HWTEST_F(NetworkShareTrackerTest, SendSharingUpstreamChange01, TestSize.Level1)
685 {
686     NetworkShareTracker::GetInstance().sharingEventCallback_.clear();
687     NetworkShareTracker::GetInstance().SendSharingUpstreamChange(nullptr);
688 
689     sptr<ISharingEventCallback> callback = new (std::nothrow) SharingEventTestCallback();
690     NetworkShareTracker::GetInstance().RegisterSharingEvent(callback);
691     NetworkShareTracker::GetInstance().SendSharingUpstreamChange(nullptr);
692     EXPECT_GE(NetworkShareTracker::GetInstance().sharingEventCallback_.size(), 0);
693 }
694 
695 HWTEST_F(NetworkShareTrackerTest, SubSmStateToExportState01, TestSize.Level1)
696 {
697     int state = SUB_SM_STATE_AVAILABLE;
698     auto ret = NetworkShareTracker::GetInstance().SubSmStateToExportState(state);
699     EXPECT_EQ(ret, SharingIfaceState::SHARING_NIC_CAN_SERVER);
700 
701     state = SUB_SM_STATE_SHARED;
702     ret = NetworkShareTracker::GetInstance().SubSmStateToExportState(state);
703     EXPECT_EQ(ret, SharingIfaceState::SHARING_NIC_SERVING);
704 
705     state = SUB_SM_STATE_UNAVAILABLE;
706     ret = NetworkShareTracker::GetInstance().SubSmStateToExportState(state);
707     EXPECT_EQ(ret, SharingIfaceState::SHARING_NIC_ERROR);
708 
709     state = 4;
710     ret = NetworkShareTracker::GetInstance().SubSmStateToExportState(state);
711     EXPECT_EQ(ret, SharingIfaceState::SHARING_NIC_ERROR);
712 }
713 
714 HWTEST_F(NetworkShareTrackerTest, OnChangeSharingState01, TestSize.Level1)
715 {
716     NetworkShareTracker::GetInstance().clientRequestsVector_.push_back(SharingIfaceType::SHARING_WIFI);
717     NetworkShareTracker::GetInstance().OnChangeSharingState(SharingIfaceType::SHARING_WIFI, false);
718     EXPECT_EQ(NetworkShareTracker::GetInstance().clientRequestsVector_.size(), 0);
719 }
720 
721 HWTEST_F(NetworkShareTrackerTest, NetworkShareTrackerBranchTest01, TestSize.Level1)
722 {
723 #ifdef BLUETOOTH_MODOULE
724     NetworkShareTracker::GetInstance().SetBluetoothState(Bluetooth::BTConnectState::CONNECTING);
725 #endif
726 
727     NetworkShareTracker::NetsysCallback callback;
728     std::string testString = "";
729     int testNumber = 0;
730     auto ret = callback.OnInterfaceAddressUpdated(testString, testString, testNumber, testNumber);
731     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
732 
733     ret = callback.OnInterfaceAddressRemoved(testString, testString, testNumber, testNumber);
734     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
735 
736     ret = callback.OnInterfaceAdded(testString);
737     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
738 
739     ret = callback.OnInterfaceRemoved(testString);
740     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
741 
742     ret = callback.OnInterfaceChanged(testString, false);
743     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
744 
745     ret = callback.OnInterfaceLinkStateChanged(testString, false);
746     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
747 
748     ret = callback.OnRouteChanged(false, testString, testString, testString);
749     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
750 
751     NetsysControllerCallback::DhcpResult dhcpResult;
752     ret = callback.OnDhcpSuccess(dhcpResult);
753     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
754 
755     ret = callback.OnBandwidthReachedLimit(testString, testString);
756     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
757 
758 #ifdef BLUETOOTH_MODOULE
759     std::shared_ptr<NetworkShareTracker::SharingPanObserver> observer =
760         std::make_shared<NetworkShareTracker::SharingPanObserver>();
761     Bluetooth::BluetoothRemoteDevice device;
762     int32_t cause = 0;
763     observer->OnConnectionStateChanged(device, static_cast<int32_t>(Bluetooth::BTConnectState::CONNECTING), cause);
764     observer->OnConnectionStateChanged(device, static_cast<int32_t>(Bluetooth::BTConnectState::CONNECTED), cause);
765     observer->OnConnectionStateChanged(device, static_cast<int32_t>(Bluetooth::BTConnectState::DISCONNECTING), cause);
766     observer->OnConnectionStateChanged(device, static_cast<int32_t>(Bluetooth::BTConnectState::DISCONNECTED), cause);
767     int32_t invalidValue = 100;
768     observer->OnConnectionStateChanged(device, invalidValue, cause);
769 #endif
770 }
771 } // namespace NetManagerStandard
772 } // namespace OHOS
773