1 /*
2  * Copyright (c) 2023-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 
18 #include "gtest/gtest-message.h"
19 #include "gtest/gtest-test-part.h"
20 #include "gtest/hwext/gtest-ext.h"
21 #include "gtest/hwext/gtest-tag.h"
22 
23 #include "ethernet_client.h"
24 #include "dev_interface_state.h"
25 #include "ethernet_lan_management.h"
26 #include "net_manager_constants.h"
27 
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
31 using namespace testing::ext;
32 } // namespace
33 
34 class EthernetLanManagementTest : public testing::Test {
35 public:
36     static void SetUpTestCase();
37     static void TearDownTestCase();
38     void SetUp();
39     void TearDown();
40     sptr<InterfaceConfiguration> GetNewIfaceConfig();
41 };
42 
SetUpTestCase()43 void EthernetLanManagementTest::SetUpTestCase() {}
44 
TearDownTestCase()45 void EthernetLanManagementTest::TearDownTestCase() {}
46 
SetUp()47 void EthernetLanManagementTest::SetUp() {}
48 
TearDown()49 void EthernetLanManagementTest::TearDown() {}
50 
51 constexpr const char *DEV_NAME = "eth2";
52 
GetNewIfaceConfig()53 sptr<InterfaceConfiguration> EthernetLanManagementTest::GetNewIfaceConfig()
54 {
55     sptr<InterfaceConfiguration> ic = (std::make_unique<InterfaceConfiguration>()).release();
56     if (!ic) {
57         return ic;
58     }
59 
60     INetAddr ipv4Addr;
61     ipv4Addr.type_ = INetAddr::IPV4;
62     ipv4Addr.address_ = "10.14.0.99";
63     ipv4Addr.netMask_ = "255.255.255.0";
64     ic->ipStatic_.ipAddrList_.push_back(ipv4Addr);
65     INetAddr route;
66     route.type_ = INetAddr::IPV4;
67     route.address_ = "0.0.0.0";
68     route.netMask_ = "0.0.0.0";
69     ic->ipStatic_.routeList_.push_back(route);
70     INetAddr gateway;
71     gateway.type_ = INetAddr::IPV4;
72     gateway.address_ = "10.14.0.1";
73     ic->ipStatic_.gatewayList_.push_back(gateway);
74     return ic;
75 }
76 
77 HWTEST_F(EthernetLanManagementTest, EthernetLanManagement001, TestSize.Level1)
78 {
79     EthernetLanManagement ethernetLanManager;
80     sptr<DevInterfaceState> devState = nullptr;
81     int32_t ret = ethernetLanManager.UpdateLanLinkInfo(devState);
82     ASSERT_EQ(ret, NETMANAGER_ERR_INTERNAL);
83 
84     sptr<DevInterfaceState> newDevState = new (std::nothrow) DevInterfaceState();
85     sptr<InterfaceConfiguration> newIc = GetNewIfaceConfig();
86     newIc->mode_ = LAN_STATIC;
87     newDevState->SetDevName(DEV_NAME);
88     newDevState->SetLancfg(newIc);
89     ret = ethernetLanManager.UpdateLanLinkInfo(newDevState);
90     ASSERT_EQ(ret, ETHERNET_ERR_DEVICE_NOT_LINK);
91 
92     newDevState->SetLinkUp(true);
93     ret = ethernetLanManager.UpdateLanLinkInfo(newDevState);
94     ASSERT_EQ(ret, (NETMANAGER_ERR_PERMISSION_DENIED + NETMANAGER_ERR_PERMISSION_DENIED));
95 
96     sptr<NetLinkInfo> linkInfo = nullptr;
97     newDevState->SetlinkInfo(linkInfo);
98     ret = ethernetLanManager.UpdateLanLinkInfo(newDevState);
99     ASSERT_EQ(ret, NETMANAGER_ERR_INTERNAL);
100 }
101 
102 HWTEST_F(EthernetLanManagementTest, EthernetLanManagement002, TestSize.Level1)
103 {
104     EthernetLanManagement ethernetLanManager;
105     NetLinkInfo netLinkInfo;
106     int32_t ret = ethernetLanManager.DelIp(netLinkInfo);
107     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
108     ret = ethernetLanManager.SetIp(netLinkInfo);
109     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
110     ret = ethernetLanManager.DelRoute(netLinkInfo);
111     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
112     ret = ethernetLanManager.SetRoute(netLinkInfo);
113     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
114 
115     sptr<InterfaceConfiguration> newIc = GetNewIfaceConfig();
116     sptr<DevInterfaceState> setDevState = new (std::nothrow) DevInterfaceState();
117     newIc->mode_ = LAN_STATIC;
118     setDevState->SetDevName(DEV_NAME);
119     setDevState->SetLinkUp(true);
120     setDevState->SetLancfg(newIc);
121     netLinkInfo = *(setDevState->GetLinkInfo());
122     ret = ethernetLanManager.DelIp(netLinkInfo);
123     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
124     ret = ethernetLanManager.SetIp(netLinkInfo);
125     ASSERT_EQ(ret, NETMANAGER_ERR_PERMISSION_DENIED);
126     ret = ethernetLanManager.DelRoute(netLinkInfo);
127     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
128     ret = ethernetLanManager.SetRoute(netLinkInfo);
129     ASSERT_EQ(ret, NETMANAGER_ERR_PERMISSION_DENIED);
130 }
131 
132 HWTEST_F(EthernetLanManagementTest, EthernetLanManagement003, TestSize.Level1)
133 {
134     EthernetLanManagement ethernetLanManager;
135     NetLinkInfo netLinkInfo;
136     int32_t ret = ethernetLanManager.DelIp(netLinkInfo);
137     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
138     ret = ethernetLanManager.SetIp(netLinkInfo);
139     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
140     ret = ethernetLanManager.DelIp(netLinkInfo);
141     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
142 }
143 
144 HWTEST_F(EthernetLanManagementTest, EthernetLanManagement004, TestSize.Level1)
145 {
146     EthernetLanManagement ethernetLanManager;
147     NetLinkInfo netLinkInfo;
148     int32_t ret = ethernetLanManager.DelRoute(netLinkInfo);
149     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
150     ret = ethernetLanManager.SetRoute(netLinkInfo);
151     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
152     ret = ethernetLanManager.DelRoute(netLinkInfo);
153     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
154 }
155 
156 HWTEST_F(EthernetLanManagementTest, EthernetLanManagementBranchTest001, TestSize.Level1)
157 {
158     EthernetLanManagement ethernetLanManager;
159     sptr<DevInterfaceState> devState = nullptr;
160     ethernetLanManager.GetOldLinkInfo(devState);
161     int32_t ret = ethernetLanManager.ReleaseLanNetLink(devState);
162     EXPECT_EQ(ret, NETMANAGER_ERR_INTERNAL);
163 
164     devState = new (std::nothrow) DevInterfaceState();
165     ethernetLanManager.GetOldLinkInfo(devState);
166     ret = ethernetLanManager.ReleaseLanNetLink(devState);
167     EXPECT_EQ(ret, NETMANAGER_ERR_INTERNAL);
168 
169     sptr<NetLinkInfo> linkInfo = new (std::nothrow) NetLinkInfo();
170     devState->SetlinkInfo(linkInfo);
171     ethernetLanManager.GetOldLinkInfo(devState);
172     ret = ethernetLanManager.ReleaseLanNetLink(devState);
173     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
174 }
175 } // namespace NetManagerStandard
176 } // namespace OHOS
177