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 <securec.h>
18
19 #include "softbus_adapter_mem.h"
20 #include "softbus_htp_socket.c"
21 #include "softbus_htp_socket.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 class SoftBusHtpSocketTest : public testing::Test {
27 public:
SoftBusHtpSocketTest()28 SoftBusHtpSocketTest() { }
~SoftBusHtpSocketTest()29 ~SoftBusHtpSocketTest() { }
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
SetUp()32 void SetUp() override { }
TearDown()33 void TearDown() override { }
34 };
35
SetUpTestCase(void)36 void SoftBusHtpSocketTest::SetUpTestCase(void) { }
37
TearDownTestCase(void)38 void SoftBusHtpSocketTest::TearDownTestCase(void) { }
39
40 /**
41 * @tc.name: SoftBusHtpSocketTest001
42 * @tc.desc: test GetHtpProtocol function.
43 * @tc.type: FUNC
44 * @tc.require:
45 */
46 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest001, TestSize.Level1)
47 {
48 const SocketInterface *interface = GetHtpProtocol();
49 EXPECT_NE(interface, nullptr);
50 }
51
52 /**
53 * @tc.name: SoftBusHtpSocketTest002
54 * @tc.desc: test GetHtpSockPort function.
55 * @tc.type: FUNC
56 * @tc.require:
57 */
58 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest002, TestSize.Level1)
59 {
60 int32_t fd = 1;
61
62 int32_t ret = GetHtpSockPort(fd);
63 EXPECT_EQ(ret, SOFTBUS_ADAPTER_ERR);
64 }
65
66 /**
67 * @tc.name: SoftBusHtpSocketTest003
68 * @tc.desc: test OpenHtpServerSocket function.
69 * @tc.type: FUNC
70 * @tc.require:
71 */
72 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest003, TestSize.Level1)
73 {
74 LocalListenerInfo *option =
75 static_cast<LocalListenerInfo *>(SoftBusCalloc(sizeof(LocalListenerInfo)));
76 EXPECT_TRUE(option != nullptr);
77
78 int32_t ret = OpenHtpServerSocket(nullptr);
79 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
80
81 option->type = CONNECT_P2P;
82 ret = OpenHtpServerSocket(option);
83 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
84
85 option->type = CONNECT_HML;
86 option->socketOption.port = SOFTBUS_ADAPTER_ERR;
87 ret = OpenHtpServerSocket(option);
88 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
89
90 option->type = CONNECT_HML;
91 option->socketOption.port = 0;
92 ret = OpenHtpServerSocket(option);
93 EXPECT_NE(ret, SOFTBUS_OK);
94 SoftBusFree(option);
95 }
96
97 /**
98 * @tc.name: SoftBusHtpSocketTest004
99 * @tc.desc: test OpenHtpClientSocket function.
100 * @tc.type: FUNC
101 * @tc.require:
102 */
103 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest004, TestSize.Level1)
104 {
105 ConnectOption *option =
106 static_cast<ConnectOption *>(SoftBusCalloc(sizeof(ConnectOption)));
107 EXPECT_TRUE(option != nullptr);
108 const char *myIp = "1111"; // test value
109 bool isNonBlock = true;
110
111 int32_t ret = OpenHtpClientSocket(nullptr, myIp, isNonBlock);
112 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
113
114 option->type = CONNECT_P2P;
115 ret = OpenHtpClientSocket(option, myIp, isNonBlock);
116 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
117
118 option->type = CONNECT_HML;
119 option->socketOption.port = 0;
120 ret = OpenHtpClientSocket(option, myIp, isNonBlock);
121 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
122
123 option->type = CONNECT_HML;
124 option->socketOption.port = 1;
125 option->socketOption.addr[0] = '\0';
126 ret = OpenHtpClientSocket(option, myIp, isNonBlock);
127 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
128
129 option->type = CONNECT_HML;
130 option->socketOption.port = 1;
131 option->socketOption.addr[0] = '1';
132 ret = OpenHtpClientSocket(option, myIp, isNonBlock);
133 EXPECT_NE(ret, SOFTBUS_OK);
134 SoftBusFree(option);
135 }
136
137 /**
138 * @tc.name: SoftBusHtpSocketTest005
139 * @tc.desc: test AcceptHtpClient function.
140 * @tc.type: FUNC
141 * @tc.require:
142 */
143 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest005, TestSize.Level1)
144 {
145 int32_t fd = 1;
146 int32_t cfd = 1;
147 ConnectOption *clientAddr = static_cast<ConnectOption *>(SoftBusCalloc(sizeof(ConnectOption)));
148 EXPECT_TRUE(clientAddr != nullptr);
149
150 int32_t ret = AcceptHtpClient(fd, nullptr, nullptr);
151 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
152
153 ret = AcceptHtpClient(fd, clientAddr, nullptr);
154 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
155
156 ret = AcceptHtpClient(fd, clientAddr, &cfd);
157 EXPECT_NE(ret, SOFTBUS_OK);
158 SoftBusFree(clientAddr);
159 }
160
161 /**
162 * @tc.name: SoftBusHtpSocketTest006
163 * @tc.desc: test MacToHtpAddr function.
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest006, TestSize.Level1)
168 {
169 SoftBusSockAddrHtp *addr = static_cast<SoftBusSockAddrHtp *>(SoftBusCalloc(sizeof(SoftBusSockAddrHtp)));
170 EXPECT_TRUE(addr != nullptr);
171 const char *mac = "1111"; // test value
172 uint16_t port = 1;
173
174 int32_t ret = MacToHtpAddr(nullptr, nullptr, port);
175 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
176
177 ret = MacToHtpAddr(mac, nullptr, port);
178 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
179
180 ret = MacToHtpAddr(mac, addr, port);
181 EXPECT_NE(ret, SOFTBUS_OK);
182 SoftBusFree(addr);
183 }
184
185 /**
186 * @tc.name: SoftBusHtpSocketTest007
187 * @tc.desc: test HtpConnect function.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest007, TestSize.Level1)
192 {
193 int32_t fd = 1;
194 const char *mac = "1111"; // test value
195 uint16_t port = 1;
196
197 int32_t ret = HtpConnect(fd, mac, port);
198 EXPECT_NE(ret, SOFTBUS_OK);
199 }
200
201 /**
202 * @tc.name: SoftBusHtpSocketTest008
203 * @tc.desc: test BindLocalMac function.
204 * @tc.type: FUNC
205 * @tc.require:
206 */
207 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest008, TestSize.Level1)
208 {
209 int32_t fd = 1;
210 const char *mac = "1111"; // test value
211 uint16_t port = 1;
212
213 int32_t ret = BindLocalMac(fd, mac, port);
214 EXPECT_NE(ret, SOFTBUS_OK);
215 }
216
217 /**
218 * @tc.name: SoftBusHtpSocketTest009
219 * @tc.desc: test GetHtpSockPort function.
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(SoftBusHtpSocketTest, SoftBusHtpSocketTest009, TestSize.Level1)
224 {
225 int32_t fd = 1;
226
227 int32_t ret = GetHtpSockPort(fd);
228 EXPECT_NE(ret, SOFTBUS_OK);
229 }
230 }
231