1 /*
2 * Copyright (c) 2025 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 #include "vpn_config.h"
18 #include "netmgr_ext_log_wrapper.h"
19
20 namespace OHOS {
21 namespace NetManagerStandard {
22 namespace {
23 using namespace testing::ext;
24 }
25
26 class VpnConfigTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase()34 void VpnConfigTest::SetUpTestCase() {};
35
TearDownTestCase()36 void VpnConfigTest::TearDownTestCase() {};
37
SetUp()38 void VpnConfigTest::SetUp() {};
39
TearDown()40 void VpnConfigTest::TearDown() {};
41
42 HWTEST_F(VpnConfigTest, MarshallingAddrRouteTest001, TestSize.Level1)
43 {
44 VpnConfig vpnconfig;
45 Parcel parcel;
46 INetAddr inetaddr;
47 inetaddr.address_ = "123";
48 vpnconfig.addresses_.push_back(inetaddr);
49 Route route;
50 route.iface_ = "123";
51 vpnconfig.routes_.push_back(route);
52 auto result = vpnconfig.MarshallingAddrRoute(parcel);
53 EXPECT_EQ(result, true);
54 }
55
56 HWTEST_F(VpnConfigTest, MarshallingVectorStringTest001, TestSize.Level1)
57 {
58 VpnConfig vpnconfig;
59 Parcel parcel;
60 std::vector<std::string> vec = {"123"};
61 auto result = vpnconfig.MarshallingVectorString(parcel, vec);
62 EXPECT_EQ(result, true);
63 }
64
65 HWTEST_F(VpnConfigTest, UnmarshallingTest001, TestSize.Level1)
66 {
67 VpnConfig vpnconfig;
68 Parcel parcel;
69 auto result = vpnconfig.Unmarshalling(parcel);
70 EXPECT_EQ(result, nullptr);
71 }
72
73 HWTEST_F(VpnConfigTest, UnmarshallingVpnConfigTest001, TestSize.Level1)
74 {
75 VpnConfig vpnconfig;
76 Parcel parcel;
77 auto result = vpnconfig.UnmarshallingVpnConfig(parcel, nullptr);
78 EXPECT_EQ(result, false);
79 }
80
81 HWTEST_F(VpnConfigTest, UnmarshallingAddrRouteTest001, TestSize.Level1)
82 {
83 VpnConfig vpnconfig;
84 Parcel parcel;
85 int32_t largeAddrSize = 4097;
86 parcel.WriteInt32(largeAddrSize);
87 auto result = vpnconfig.UnmarshallingAddrRoute(parcel, &vpnconfig);
88 EXPECT_EQ(result, false);
89 }
90
91 HWTEST_F(VpnConfigTest, UnmarshallingAddrRouteTest002, TestSize.Level1)
92 {
93 VpnConfig vpnconfig;
94 Parcel parcel;
95 int32_t addrSize = 1;
96 parcel.WriteInt32(addrSize);
97 parcel.WriteInt32(-1);
98 auto result = vpnconfig.UnmarshallingAddrRoute(parcel, &vpnconfig);
99 EXPECT_EQ(result, false);
100 }
101
102 HWTEST_F(VpnConfigTest, UnmarshallingAddrRouteTest003, TestSize.Level1)
103 {
104 VpnConfig vpnconfig;
105 Parcel parcel;
106 int32_t addrSize = 1;
107 parcel.WriteInt32(addrSize);
108 sptr<INetAddr> validAddress = new INetAddr();
109 validAddress->type_ = INetAddr::IPV4;
110 validAddress->address_ = "192.168.1.1";
111 validAddress->Marshalling(parcel);
112
113 int32_t routeSize = 1;
114 parcel.WriteInt32(routeSize);
115 parcel.WriteInt32(-1);
116 auto result = vpnconfig.UnmarshallingAddrRoute(parcel, &vpnconfig);
117 EXPECT_EQ(result, false);
118 }
119
120 HWTEST_F(VpnConfigTest, UnmarshallingAddrRouteTest004, TestSize.Level1)
121 {
122 VpnConfig vpnconfig;
123 Parcel parcel;
124 int32_t addrSize = 1;
125 parcel.WriteInt32(addrSize);
126 sptr<INetAddr> validAddress = new INetAddr();
127 validAddress->type_ = INetAddr::IPV4;
128 validAddress->address_ = "192.168.1.1";
129 validAddress->Marshalling(parcel);
130
131 int32_t largeRouteSize = 2001;
132 parcel.WriteInt32(largeRouteSize);
133 auto result = vpnconfig.UnmarshallingAddrRoute(parcel, &vpnconfig);
134 EXPECT_EQ(result, false);
135 }
136
137 HWTEST_F(VpnConfigTest, UnmarshallingAddrRouteTest005, TestSize.Level1)
138 {
139 VpnConfig vpnconfig;
140 Parcel parcel;
141
142 int32_t addrSize = 1;
143 parcel.WriteInt32(addrSize);
144
145 sptr<INetAddr> validAddress1 = new INetAddr();
146 validAddress1->type_ = INetAddr::IPV4;
147 validAddress1->address_ = "192.168.1.1";
148 validAddress1->Marshalling(parcel);
149
150 int32_t routeSize = 1;
151 parcel.WriteInt32(routeSize);
152
153 sptr<INetAddr> destination = new INetAddr();
154 destination->type_ = INetAddr::IPV4;
155 destination->address_ = "0.0.0.0";
156
157 sptr<INetAddr> gateway = new INetAddr();
158 gateway->type_ = INetAddr::IPV4;
159 gateway->address_ = "192.168.1.1";
160
161 sptr<Route> validRoute1 = new Route();
162 validRoute1->iface_ = "eth0";
163 validRoute1->destination_ = *destination;
164 validRoute1->gateway_ = *gateway;
165 validRoute1->rtnType_ = RTN_UNICAST;
166 validRoute1->mtu_ = 1500;
167 validRoute1->isHost_ = false;
168 validRoute1->hasGateway_ = true;
169 validRoute1->isDefaultRoute_ = true;
170
171 validRoute1->Marshalling(parcel);
172
173 auto result = vpnconfig.UnmarshallingAddrRoute(parcel, &vpnconfig);
174
175 EXPECT_EQ(result, true);
176 EXPECT_EQ(vpnconfig.addresses_.size(), 1);
177 EXPECT_EQ(vpnconfig.addresses_[0].address_, "192.168.1.1");
178 EXPECT_EQ(vpnconfig.routes_.size(), 1);
179 EXPECT_EQ(vpnconfig.routes_[0].iface_, "eth0");
180 EXPECT_EQ(vpnconfig.routes_[0].destination_.address_, "0.0.0.0");
181 EXPECT_EQ(vpnconfig.routes_[0].gateway_.address_, "192.168.1.1");
182 EXPECT_EQ(vpnconfig.routes_[0].rtnType_, RTN_UNICAST);
183 EXPECT_EQ(vpnconfig.routes_[0].mtu_, 1500);
184 EXPECT_EQ(vpnconfig.routes_[0].isHost_, false);
185 EXPECT_EQ(vpnconfig.routes_[0].hasGateway_, true);
186 EXPECT_EQ(vpnconfig.routes_[0].isDefaultRoute_, true);
187 }
188
189 HWTEST_F(VpnConfigTest, UnmarshallingVectorStringTest001, TestSize.Level1)
190 {
191 VpnConfig vpnconfig;
192 Parcel parcel;
193 std::vector<std::string> vec;
194
195 uint32_t largeSize = 4097;
196 parcel.WriteInt32(largeSize);
197
198 auto result = vpnconfig.UnmarshallingVectorString(parcel, vec);
199 EXPECT_EQ(result, false);
200 EXPECT_EQ(vec.size(), 0);
201 }
202
203 HWTEST_F(VpnConfigTest, UnmarshallingVectorStringTest002, TestSize.Level1)
204 {
205 VpnConfig vpnconfig;
206 Parcel parcel;
207 std::vector<std::string> vec;
208
209 int32_t size = 2;
210 parcel.WriteInt32(size);
211
212 std::string str1 = "string1";
213 std::string str2 = "string2";
214 parcel.WriteString(str1);
215 parcel.WriteString(str2);
216
217 auto result = vpnconfig.UnmarshallingVectorString(parcel, vec);
218 EXPECT_EQ(result, true);
219 EXPECT_EQ(vec.size(), 2);
220 EXPECT_EQ(vec[0], str1);
221 EXPECT_EQ(vec[1], str2);
222 }
223 }
224 }