1 /*
2 * Copyright (c) 2022 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 <cstdio>
17
18 #include <gtest/gtest.h>
19
20 #include "net_manager_constants.h"
21 #define private public
22 #include "sharing_manager.h"
23 #undef private
24
25 namespace OHOS {
26 namespace NetsysNative {
27 namespace {
28 using namespace testing::ext;
29 using namespace nmd;
30 } // namespace
31
32 class SharingManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 static inline std::shared_ptr<SharingManager> sharingManager = nullptr;
39 };
40
SetUpTestCase()41 void SharingManagerTest::SetUpTestCase()
42 {
43 sharingManager = std::make_shared<SharingManager>();
44 }
45
TearDownTestCase()46 void SharingManagerTest::TearDownTestCase() {}
47
SetUp()48 void SharingManagerTest::SetUp() {}
49
TearDown()50 void SharingManagerTest::TearDown() {}
51
52 HWTEST_F(SharingManagerTest, IpEnableForwardingTest, TestSize.Level1)
53 {
54 auto result = sharingManager->IpEnableForwarding("aTestName");
55 ASSERT_EQ(result, 0);
56 }
57
58 HWTEST_F(SharingManagerTest, IpDisableForwarding, TestSize.Level1)
59 {
60 auto result = sharingManager->IpDisableForwarding("aTestName");
61 ASSERT_EQ(result, 0);
62 }
63
64 HWTEST_F(SharingManagerTest, EnableNat001, TestSize.Level1)
65 {
66 auto result = sharingManager->EnableNat("down", "up");
67 ASSERT_EQ(result, 0);
68 }
69
70 HWTEST_F(SharingManagerTest, EnableNat002, TestSize.Level1)
71 {
72 const std::string enableAction = "down";
73 int32_t ret = sharingManager->EnableNat(enableAction, enableAction);
74 ASSERT_EQ(ret, -1);
75
76 const std::string upstreamIface = "_test0";
77 ret = sharingManager->EnableNat(enableAction, upstreamIface);
78 ASSERT_EQ(ret, -1);
79
80 const std::string nullIface;
81 ret = sharingManager->EnableNat(enableAction, nullIface);
82 ASSERT_EQ(ret, -1);
83 }
84
85 HWTEST_F(SharingManagerTest, DisableNat001, TestSize.Level1)
86 {
87 sharingManager->DisableNat("down", "up");
88 ASSERT_STREQ("0", "0");
89 }
90
91 HWTEST_F(SharingManagerTest, DisableNat002, TestSize.Level1)
92 {
93 const std::string enableAction = "down";
94 int32_t ret = sharingManager->DisableNat(enableAction, enableAction);
95 ASSERT_EQ(ret, -1);
96
97 const std::string upstreamIface = "_test0";
98 ret = sharingManager->DisableNat(enableAction, upstreamIface);
99 ASSERT_EQ(ret, -1);
100
101 const std::string nullIface;
102 ret = sharingManager->DisableNat(enableAction, nullIface);
103 ASSERT_EQ(ret, -1);
104 }
105
106 HWTEST_F(SharingManagerTest, IpFwdAddInterfaceForward001, TestSize.Level1)
107 {
108 sharingManager->IpfwdAddInterfaceForward("down", "up");
109 ASSERT_STREQ("0", "0");
110 }
111
112 HWTEST_F(SharingManagerTest, IpFwdAddInterfaceForward002, TestSize.Level1)
113 {
114 const std::string enableAction = "down";
115 int32_t ret = sharingManager->IpfwdAddInterfaceForward(enableAction, enableAction);
116 ASSERT_EQ(ret, -1);
117 const std::string fromIface = "_err";
118 ret = sharingManager->IpfwdAddInterfaceForward(fromIface, enableAction);
119 EXPECT_EQ(ret, -1);
120 const std::string upstreamIface = "_test0";
121 ret = sharingManager->IpfwdAddInterfaceForward(enableAction, upstreamIface);
122 EXPECT_EQ(ret, -1);
123 }
124
125 HWTEST_F(SharingManagerTest, IpFwdRemoveInterfaceForward001, TestSize.Level1)
126 {
127 sharingManager->IpfwdRemoveInterfaceForward("down", "up");
128 ASSERT_STREQ("0", "0");
129 }
130
131 HWTEST_F(SharingManagerTest, IpFwdRemoveInterfaceForward002, TestSize.Level1)
132 {
133 const std::string enableAction = "down";
134 int32_t ret = sharingManager->IpfwdRemoveInterfaceForward(enableAction, enableAction);
135 ASSERT_EQ(ret, -1);
136 const std::string fromIface = "_err";
137 ret = sharingManager->IpfwdRemoveInterfaceForward(fromIface, enableAction);
138 EXPECT_EQ(ret, -1);
139 const std::string upstreamIface = "_test0";
140 ret = sharingManager->IpfwdRemoveInterfaceForward(enableAction, upstreamIface);
141 EXPECT_EQ(ret, -1);
142 }
143
144 HWTEST_F(SharingManagerTest, GetNetworkSharingTraffic001, TestSize.Level1)
145 {
146 std::string downIface = "down0";
147 std::string upIface = "up0";
148 NetworkSharingTraffic traffic;
149 int32_t ret = sharingManager->GetNetworkSharingTraffic(downIface, upIface, traffic);
150 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
151 }
152
153 HWTEST_F(SharingManagerTest, GetNetworkSharingTraffic002, TestSize.Level1)
154 {
155 std::string downIface = "eth0";
156 std::string upIface = "wlan0";
157 NetworkSharingTraffic traffic;
158 int32_t ret = sharingManager->GetNetworkSharingTraffic(downIface, upIface, traffic);
159 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
160 }
161
162 HWTEST_F(SharingManagerTest, SetIpFwdEnable001, TestSize.Level1)
163 {
164 int32_t ret = sharingManager->SetIpFwdEnable();
165 EXPECT_EQ(ret, 0);
166 ret = sharingManager->SetForwardRules(false, " tetherctrl_FORWARD -j DROP");
167 EXPECT_EQ(ret, 0);
168 }
169 } // namespace NetsysNative
170 } // namespace OHOS
171