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_mintp_socket.c"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 class SoftBusMintpSocketTest : public testing::Test {
25 public:
SoftBusMintpSocketTest()26 SoftBusMintpSocketTest() { }
~SoftBusMintpSocketTest()27 ~SoftBusMintpSocketTest() { }
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
SetUp()30 void SetUp() override { }
TearDown()31 void TearDown() override { }
32 };
33
SetUpTestCase(void)34 void SoftBusMintpSocketTest::SetUpTestCase(void) { }
35
TearDownTestCase(void)36 void SoftBusMintpSocketTest::TearDownTestCase(void) { }
37
38 /**
39 * @tc.name: SetMintpSocketTest001
40 * @tc.desc: test setsockopt function.
41 * @tc.type: FUNC
42 * @tc.require:
43 */
44 HWTEST_F(SoftBusMintpSocketTest, SetMintpSocketTest001, TestSize.Level1)
45 {
46 int32_t ret = SetMintpSocketMsgSize(-1);
47 EXPECT_NE(ret, SOFTBUS_OK);
48 ret = SetMintpSocketTos(-1, 0);
49 EXPECT_NE(ret, SOFTBUS_OK);
50 ret = SetMintpSocketTransType(-1, 0);
51 EXPECT_NE(ret, SOFTBUS_OK);
52 ret = SetMintpSocketKeepAlive(-1, 0);
53 EXPECT_NE(ret, SOFTBUS_OK);
54 ret = SetMintpSocketKeepAlive(-1, 1000);
55 EXPECT_NE(ret, SOFTBUS_OK);
56 ret = SetMintpSocketTimeSync(-1, nullptr);
57 EXPECT_NE(ret, SOFTBUS_OK);
58 MintpTimeSync timeSync;
59 ret = SetMintpSocketTimeSync(-1, &timeSync);
60 EXPECT_NE(ret, SOFTBUS_OK);
61 SetMintpOption(-1);
62 }
63
64 /**
65 * @tc.name:BindMintpTest002
66 * @tc.desc: test BindMintp function.
67 * @tc.type: FUNC
68 * @tc.require:
69 */
70 HWTEST_F(SoftBusMintpSocketTest, BindMintpTest002, TestSize.Level1)
71 {
72 int32_t ret = BindMintp(SOFTBUS_AF_INET, 0, nullptr);
73 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
74 ret = BindMintp(SOFTBUS_AF_INET6, 0, nullptr);
75 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
76 const char *localIp = "127.30.1.1";
77 ret = BindMintp(SOFTBUS_AF_INET, 0, localIp);
78 EXPECT_NE(ret, SOFTBUS_SOCKET_ADDR_ERR);
79 const char *localIp6 = "12:34:56:78:90:ab";
80 ret = BindMintp(SOFTBUS_AF_INET6, 0, localIp6);
81 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
82 }
83
84 /**
85 * @tc.name:OpenMintpServerSocketTest003
86 * @tc.desc: test OpenMintpServerSocket function.
87 * @tc.type: FUNC
88 * @tc.require:
89 */
90 HWTEST_F(SoftBusMintpSocketTest, OpenMintpServerSocketTest003, TestSize.Level1)
91 {
92 int32_t ret = OpenMintpServerSocket(nullptr);
93 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
94 LocalListenerInfo option;
95 option.type = CONNECT_TCP;
96 ret = OpenMintpServerSocket(&option);
97 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
98 option.type = CONNECT_HML;
99 option.socketOption.port = -1;
100 ret = OpenMintpServerSocket(&option);
101 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
102 option.socketOption.port = 0;
103 (void)strcpy_s(option.socketOption.addr, IP_LEN, "127.30.1.1");
104 ret = OpenMintpServerSocket(&option);
105 }
106
107 /**
108 * @tc.name:MintpSocketConnectTest004
109 * @tc.desc: test MintpSocketConnect function.
110 * @tc.type: FUNC
111 * @tc.require:
112 */
113 HWTEST_F(SoftBusMintpSocketTest, MintpSocketConnectTest004, TestSize.Level1)
114 {
115 ConnectOption option;
116 option.type = CONNECT_HML;
117 option.socketOption.port = 1;
118 (void)strcpy_s(option.socketOption.addr, IP_LEN, "127.30.1.1");
119 int32_t ret = MintpSocketConnect(0, SOFTBUS_AF_INET, &option);
120 EXPECT_NE(ret, SOFTBUS_ADAPTER_OK);
121 (void)strcpy_s(option.socketOption.addr, IP_LEN, "12:34:56:78:90:ab");
122 ret = MintpSocketConnect(0, SOFTBUS_PF_INET6, &option);
123 EXPECT_NE(ret, SOFTBUS_ADAPTER_OK);
124 (void)strcpy_s(option.socketOption.addr, IP_LEN, "\0");
125 ret = MintpSocketConnect(0, SOFTBUS_AF_INET, &option);
126 EXPECT_NE(ret, SOFTBUS_ADAPTER_OK);
127 ret = MintpSocketConnect(0, SOFTBUS_PF_INET6, &option);
128 EXPECT_NE(ret, SOFTBUS_ADAPTER_OK);
129 }
130
131 /**
132 * @tc.name: OpenMintpClientSocketTest005
133 * @tc.desc: test OpenMintpClientSocket function.
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(SoftBusMintpSocketTest, OpenMintpClientSocketTest005, TestSize.Level1)
138 {
139 int32_t ret = OpenMintpClientSocket(nullptr, nullptr, false);
140 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
141 ConnectOption option;
142 ret = OpenMintpClientSocket(&option, nullptr, false);
143 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
144 option.type = CONNECT_TCP;
145 const char *myIp = "127.29.1.1";
146 ret = OpenMintpClientSocket(&option, myIp, false);
147 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
148 option.type = CONNECT_HML;
149 option.socketOption.port = -1;
150 ret = OpenMintpClientSocket(&option, myIp, false);
151 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
152 option.socketOption.port = 1;
153 (void)strcpy_s(option.socketOption.addr, IP_LEN, "\0");
154 ret = OpenMintpClientSocket(&option, myIp, false);
155 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
156 (void)strcpy_s(option.socketOption.addr, IP_LEN, "127.29.1.2");
157 ret = OpenMintpClientSocket(&option, myIp, false);
158 EXPECT_NE(ret, SOFTBUS_OK);
159 ret = OpenMintpClientSocket(&option, myIp, true);
160 EXPECT_NE(ret, SOFTBUS_OK);
161 }
162
163 /**
164 * @tc.name: GetMintpSockPortTest006
165 * @tc.desc: test GetMintpSockPort function.
166 * @tc.type: FUNC
167 * @tc.require:
168 */
169 HWTEST_F(SoftBusMintpSocketTest, GetMintpSockPortTest006, TestSize.Level1)
170 {
171 int32_t ret = GetMintpSockPort(-1);
172 EXPECT_NE(ret, SOFTBUS_OK);
173 }
174
175 /**
176 * @tc.name: AcceptMintpClientTest007
177 * @tc.desc: test AcceptMintpClient function.
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(SoftBusMintpSocketTest, AcceptMintpClientTest007, TestSize.Level1)
182 {
183 int32_t ret = AcceptMintpClient(-1, nullptr, nullptr);
184 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
185 ConnectOption clientAddr;
186 ret = AcceptMintpClient(-1, &clientAddr, nullptr);
187 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
188 int32_t cfd = -1;
189 ret = AcceptMintpClient(-1, &clientAddr, &cfd);
190 EXPECT_NE(ret, SOFTBUS_OK);
191 }
192
193 /**
194 * @tc.name: GetMintpProtocolTest008
195 * @tc.desc: test GetMintpProtocol function.
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(SoftBusMintpSocketTest, GetMintpProtocolTest008, TestSize.Level1)
200 {
201 const SocketInterface *interface = GetMintpProtocol();
202 EXPECT_NE(interface, nullptr);
203 }
204 } // namespace OHOS
205