1 /*
2 * Copyright (c) 2022-2023 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 "net_manager_constants.h"
17 #include "notify_callback_stub.h"
18 #include <algorithm>
19 #include <gtest/gtest.h>
20 #include <iostream>
21 #include <string>
22 #include <vector>
23
24 #ifdef GTEST_API_
25 #define private public
26 #define protected public
27 #endif
28 #include "wrapper_distributor.h"
29
30 namespace OHOS {
31 namespace nmd {
32 namespace {
33 using namespace testing::ext;
34 using namespace std;
35 using namespace NetManagerStandard;
36 using namespace NetsysNative;
37 constexpr int32_t TEST_SOCKET = 112;
38 constexpr int32_t TEST_FORMAT = NetlinkDefine::NETLINK_FORMAT_BINARY_UNICAST;
39 constexpr const char *WIFI_AP_DEFAULT_IFACE_NAME = "wlan0";
40 mutex EXTERN_MUTEX;
41
42 class NotifyCallbackImp : public NotifyCallbackStub {
43 public:
OnInterfaceAddressUpdated(const std::string & addr,const std::string & ifName,int flags,int scope)44 int32_t OnInterfaceAddressUpdated(const std::string &addr, const std::string &ifName,
45 int flags, int scope) override
46 {
47 if (ifName == WIFI_AP_DEFAULT_IFACE_NAME) {
48 flags_ = flags;
49 }
50 return NETMANAGER_EXT_SUCCESS;
51 }
52
OnInterfaceAddressRemoved(const std::string & addr,const std::string & ifName,int flags,int scope)53 int32_t OnInterfaceAddressRemoved(const std::string &addr, const std::string &ifName,
54 int flags, int scope) override
55 {
56 if (ifName == WIFI_AP_DEFAULT_IFACE_NAME) {
57 flags_ = flags;
58 }
59 return NETMANAGER_EXT_SUCCESS;
60 }
61
OnInterfaceAdded(const std::string & ifName)62 int32_t OnInterfaceAdded(const std::string &ifName) override
63 {
64 ifnameContainer_.emplace_back(ifName);
65 return NETMANAGER_EXT_SUCCESS;
66 }
67
OnInterfaceRemoved(const std::string & ifName)68 int32_t OnInterfaceRemoved(const std::string &ifName) override
69 {
70 auto itfind = std::find(ifnameContainer_.begin(), ifnameContainer_.end(), ifName);
71 if (itfind != ifnameContainer_.end()) {
72 ifnameContainer_.erase(itfind);
73 }
74
75 return NETMANAGER_EXT_SUCCESS;
76 }
77
OnInterfaceChanged(const std::string & ifName,bool up)78 int32_t OnInterfaceChanged(const std::string &ifName, bool up) override
79 {
80 if (ifName == WIFI_AP_DEFAULT_IFACE_NAME) {
81 isWifiInterfaceChanged_ = up;
82 }
83 return NETMANAGER_EXT_SUCCESS;
84 }
85
OnInterfaceLinkStateChanged(const std::string & ifName,bool up)86 int32_t OnInterfaceLinkStateChanged(const std::string &ifName, bool up) override
87 {
88 if (ifName == WIFI_AP_DEFAULT_IFACE_NAME) {
89 isWifiLinkStateUp_ = up;
90 }
91 return NETMANAGER_EXT_SUCCESS;
92 }
93
OnRouteChanged(bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)94 int32_t OnRouteChanged(bool updated, const std::string &route, const std::string &gateway,
95 const std::string &ifName) override
96 {
97 if (ifName == WIFI_AP_DEFAULT_IFACE_NAME) {
98 isRouteUpdated_ = updated;
99 }
100 return NETMANAGER_EXT_SUCCESS;
101 }
102
OnDhcpSuccess(sptr<DhcpResultParcel> & dhcpResult)103 int32_t OnDhcpSuccess(sptr<DhcpResultParcel> &dhcpResult) override
104 {
105 return NETMANAGER_EXT_SUCCESS;
106 }
107
OnBandwidthReachedLimit(const std::string & limitName,const std::string & iface)108 int32_t OnBandwidthReachedLimit(const std::string &limitName, const std::string &iface) override
109 {
110 if (iface == WIFI_AP_DEFAULT_IFACE_NAME) {
111 alertName_ = limitName;
112 }
113 return NETMANAGER_EXT_SUCCESS;
114 }
115
116 vector<std::string> ifnameContainer_;
117 std::string alertName_;
118 int flags_ = 0;
119 bool isWifiInterfaceChanged_ = false;
120 bool isWifiLinkStateUp_ = false;
121 bool isRouteUpdated_ = false;
122 };
123
124 } // namespace
125
126 class WrapperDistributorTest : public testing::Test {
127 public:
128 static void SetUpTestCase();
129 static void TearDownTestCase();
130 void SetUp();
131 void TearDown();
132 static inline std::shared_ptr<WrapperDistributor> instance_ =
133 std::make_shared<WrapperDistributor>(TEST_SOCKET, TEST_FORMAT, EXTERN_MUTEX);
134 };
135
SetUpTestCase()136 void WrapperDistributorTest::SetUpTestCase() {}
137
TearDownTestCase()138 void WrapperDistributorTest::TearDownTestCase() {}
139
SetUp()140 void WrapperDistributorTest::SetUp() {}
141
TearDown()142 void WrapperDistributorTest::TearDown() {}
143
144 HWTEST_F(WrapperDistributorTest, SocketErrorTest001, TestSize.Level1)
145 {
146 int32_t testSocket = -1;
147 std::unique_ptr<WrapperDistributor> receiver = std::make_unique<WrapperDistributor>(testSocket, TEST_FORMAT,
148 EXTERN_MUTEX);
149 ASSERT_NE(receiver, nullptr);
150 }
151
152 HWTEST_F(WrapperDistributorTest, FormatErrorTest001, TestSize.Level1)
153 {
154 int32_t testFormat = 6;
155 std::unique_ptr<WrapperDistributor> distributor = std::make_unique<WrapperDistributor>(TEST_SOCKET, testFormat,
156 EXTERN_MUTEX);
157 ASSERT_NE(distributor, nullptr);
158 }
159
160 HWTEST_F(WrapperDistributorTest, StartTest001, TestSize.Level1)
161 {
162 int32_t ret = instance_->Start();
163 EXPECT_EQ(ret, NetlinkResult::OK);
164 }
165
166 HWTEST_F(WrapperDistributorTest, StopTest001, TestSize.Level1)
167 {
168 int32_t ret = instance_->Stop();
169 EXPECT_EQ(ret, NetlinkResult::OK);
170 }
171
172 HWTEST_F(WrapperDistributorTest, RegisterNetlinkCallbacksTest001, TestSize.Level1)
173 {
174 int32_t ret = instance_->RegisterNetlinkCallbacks(nullptr);
175 EXPECT_EQ(ret, NetlinkResult::ERR_NULL_PTR);
176 }
177
178 HWTEST_F(WrapperDistributorTest, RegisterNetlinkCallbacksTest002, TestSize.Level1)
179 {
180 std::shared_ptr<NetsysEventMessage> message = nullptr;
181 instance_->HandleDecodeSuccess(message);
182
183 auto callbacks_ = std::make_shared<std::vector<sptr<NetsysNative::INotifyCallback>>>();
184 sptr<NotifyCallbackImp> notifyCallback = new NotifyCallbackImp();
185 callbacks_->push_back(notifyCallback);
186 int32_t ret = instance_->RegisterNetlinkCallbacks(callbacks_);
187 EXPECT_EQ(ret, NetlinkResult::OK);
188
189 message = std::make_shared<NetsysEventMessage>();
190 message->SetAction(NetsysEventMessage::Action::ADD);
191 message->SetSubSys(NetsysEventMessage::SubSys::NET);
192 message->PushMessage(NetsysEventMessage::Type::INTERFACE, WIFI_AP_DEFAULT_IFACE_NAME);
193 instance_->HandleDecodeSuccess(message);
194 EXPECT_EQ(notifyCallback->ifnameContainer_.size(), 1);
195
196 message->SetAction(NetsysEventMessage::Action::REMOVE);
197 instance_->HandleDecodeSuccess(message);
198 EXPECT_EQ(notifyCallback->ifnameContainer_.size(), 0);
199
200 message->SetAction(NetsysEventMessage::Action::CHANGE);
201 instance_->HandleDecodeSuccess(message);
202 EXPECT_TRUE(notifyCallback->isWifiInterfaceChanged_);
203
204 message->SetAction(NetsysEventMessage::Action::LINKUP);
205 instance_->HandleDecodeSuccess(message);
206 EXPECT_TRUE(notifyCallback->isWifiLinkStateUp_);
207
208 message->SetAction(NetsysEventMessage::Action::LINKDOWN);
209 instance_->HandleDecodeSuccess(message);
210 EXPECT_FALSE(notifyCallback->isWifiLinkStateUp_);
211
212 message->SetAction(NetsysEventMessage::Action::ADDRESSUPDATE);
213 message->PushMessage(NetsysEventMessage::Type::ADDRESS, "127.0.0.1");
214 message->PushMessage(NetsysEventMessage::Type::FLAGS, "1");
215 message->PushMessage(NetsysEventMessage::Type::SCOPE, "1");
216 instance_->HandleDecodeSuccess(message);
217 EXPECT_EQ(notifyCallback->flags_, 1);
218
219 message->SetAction(NetsysEventMessage::Action::ADDRESSREMOVED);
220 message->PushMessage(NetsysEventMessage::Type::FLAGS, "2");
221 message->PushMessage(NetsysEventMessage::Type::SCOPE, "2");
222 instance_->HandleDecodeSuccess(message);
223 EXPECT_EQ(notifyCallback->flags_, 2);
224
225 message->SetAction(NetsysEventMessage::Action::ROUTEUPDATED);
226 message->PushMessage(NetsysEventMessage::Type::ROUTE, "route");
227 message->PushMessage(NetsysEventMessage::Type::GATEWAY, "gateway");
228 instance_->HandleDecodeSuccess(message);
229 EXPECT_TRUE(notifyCallback->isRouteUpdated_);
230
231 message->SetAction(NetsysEventMessage::Action::ROUTEREMOVED);
232 instance_->HandleDecodeSuccess(message);
233 EXPECT_FALSE(notifyCallback->isRouteUpdated_);
234
235 message->SetSubSys(NetsysEventMessage::SubSys::QLOG);
236 message->PushMessage(NetsysEventMessage::Type::ALERT_NAME, "labelName");
237 instance_->HandleDecodeSuccess(message);
238 EXPECT_EQ(notifyCallback->alertName_, "labelName");
239 }
240
241 HWTEST_F(WrapperDistributorTest, WrapperDistributorBranchTest001, TestSize.Level1)
242 {
243 instance_->netlinkCallbacks_ = nullptr;
244 std::shared_ptr<NetsysEventMessage> message = std::make_shared<NetsysEventMessage>();
245 instance_->HandleDecodeSuccess(message);
246
247 std::string ifName = "";
248 instance_->NotifyInterfaceAdd(ifName);
249 instance_->NotifyInterfaceRemove(ifName);
250 instance_->NotifyInterfaceChange(ifName, false);
251 instance_->NotifyInterfaceLinkStateChange(ifName, false);
252
253 std::string labelName = "";
254 instance_->NotifyQuotaLimitReache(labelName, ifName);
255 std::string addr = "";
256 int32_t flags = 0;
257 int32_t scope = 0;
258 instance_->NotifyInterfaceAddressUpdate(addr, ifName, flags, scope);
259 instance_->NotifyInterfaceAddressRemove(addr, ifName, flags, scope);
260
261 std::string route = "";
262 std::string gateway = "";
263 instance_->NotifyRouteChange(false, route, gateway, ifName);
264
265 int32_t ret = instance_->RegisterNetlinkCallbacks(nullptr);
266 EXPECT_EQ(ret, NetlinkResult::ERR_NULL_PTR);
267 }
268 } // namespace nmd
269 } // namespace OHOS