1 /*
2 * Copyright (c) 2024-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 "UTTest_dm_transport.h"
17 #include "dm_error_type.h"
18 #include "softbus_error_code.h"
19
20 namespace OHOS {
21 namespace DistributedHardware {
SetUp()22 void DMTransportTest::SetUp()
23 {
24 }
TearDown()25 void DMTransportTest::TearDown()
26 {
27 }
SetUpTestCase()28 void DMTransportTest::SetUpTestCase()
29 {
30 }
TearDownTestCase()31 void DMTransportTest::TearDownTestCase()
32 {
33 }
34
35 namespace {
36 constexpr int32_t SOCKETED = 101;
37 }
38 /**
39 * @tc.name: CreateClientSocket_InvalidInput
40 * @tc.type: FUNC
41 */
42 HWTEST_F(DMTransportTest, CreateClientSocket_InvalidInput, testing::ext::TestSize.Level1)
43 {
44 std::string rmtNetworkId = "";
45 EXPECT_EQ(dmTransport_->CreateClientSocket(rmtNetworkId), ERR_DM_INPUT_PARA_INVALID);
46 }
47
48 /**
49 * @tc.name: Init_Success
50 * @tc.type: FUNC
51 */
52 HWTEST_F(DMTransportTest, Init_Success, testing::ext::TestSize.Level1)
53 {
54 EXPECT_EQ(dmTransport_->Init(), ERR_DM_FAILED);
55 }
56
57 /**
58 * @tc.name: Init_AlreadyInitialized
59 * @tc.type: FUNC
60 */
61 HWTEST_F(DMTransportTest, Init_AlreadyInitialized, testing::ext::TestSize.Level1)
62 {
63 dmTransport_->Init();
64 EXPECT_EQ(dmTransport_->Init(), ERR_DM_FAILED);
65 }
66
67 /**
68 * @tc.name: UnInit_ShouldShutdownAllSockets
69 * @tc.type: FUNC
70 */
71 HWTEST_F(DMTransportTest, UnInit_ShouldShutdownAllSockets, testing::ext::TestSize.Level1)
72 {
73 int32_t socketId;
74 dmTransport_->StartSocket("device1", socketId);
75 dmTransport_->StartSocket("device2", socketId);
76
77 EXPECT_EQ(dmTransport_->UnInit(), DM_OK);
78 EXPECT_FALSE(dmTransport_->IsDeviceSessionOpened("device1", socketId));
79 EXPECT_FALSE(dmTransport_->IsDeviceSessionOpened("device2", socketId));
80 }
81
82 /**
83 * @tc.name: UnInit_ShouldNotShutdownWhenNoSockets
84 * @tc.type: FUNC
85 */
86 HWTEST_F(DMTransportTest, UnInit_ShouldNotShutdownWhenNoSockets, testing::ext::TestSize.Level1)
87 {
88 EXPECT_EQ(dmTransport_->UnInit(), DM_OK);
89 }
90
91 /**
92 * @tc.name: IsDeviceSessionOpened_ShouldReturnFalseForClosedSession
93 * @tc.type: FUNC
94 */
95 HWTEST_F(DMTransportTest, IsDeviceSessionOpened_ShouldReturnFalseForClosedSession, testing::ext::TestSize.Level1)
96 {
97 int32_t socketId;
98 EXPECT_FALSE(dmTransport_->IsDeviceSessionOpened("device2", socketId));
99 }
100
101 /**
102 * @tc.name: GetRemoteNetworkIdBySocketIdReturnEmptyString
103 * @tc.type: FUNC
104 */
105 HWTEST_F(DMTransportTest, GetRemoteNetworkIdBySocketIdReturnEmptyString, testing::ext::TestSize.Level1)
106 {
107 EXPECT_EQ(dmTransport_->GetRemoteNetworkIdBySocketId(-1), "");
108 }
109
110 /**
111 * @tc.name: ClearDeviceSocketOpened_ShouldRemoveSocket
112 * @tc.type: FUNC
113 */
114 HWTEST_F(DMTransportTest, ClearDeviceSocketOpened_ShouldRemoveSocket, testing::ext::TestSize.Level1)
115 {
116 int32_t socketId = 1;
117 dmTransport_->StartSocket("device1", socketId);
118 dmTransport_->ClearDeviceSocketOpened("device1", socketId);
119 EXPECT_FALSE(dmTransport_->IsDeviceSessionOpened("device1", socketId));
120 }
121
122 /**
123 * @tc.name: ClearDeviceSocketOpened_ShouldDoNothingForInvalidId
124 * @tc.type: FUNC
125 */
126 HWTEST_F(DMTransportTest, ClearDeviceSocketOpened_ShouldDoNothingForInvalidId, testing::ext::TestSize.Level1)
127 {
128 int32_t socketId = 1;
129 dmTransport_->StartSocket("device1", socketId);
130 dmTransport_->ClearDeviceSocketOpened("invalid_device", socketId);
131 EXPECT_FALSE(dmTransport_->IsDeviceSessionOpened("device1", socketId));
132 }
133
134 /**
135 * @tc.name: StartSocket_ShouldCreateSocket
136 * @tc.type: FUNC
137 */
138 HWTEST_F(DMTransportTest, StartSocket_ShouldCreateSocket, testing::ext::TestSize.Level1)
139 {
140 int32_t socketId;
141 EXPECT_EQ(dmTransport_->StartSocket("device1", socketId), ERR_DM_FAILED);
142 EXPECT_FALSE(dmTransport_->IsDeviceSessionOpened("device1", socketId));
143 }
144
145 /**
146 * @tc.name: StartSocket_ShouldReturnErrorForInvalidId
147 * @tc.type: FUNC
148 */
149 HWTEST_F(DMTransportTest, StartSocket_ShouldReturnErrorForInvalidId, testing::ext::TestSize.Level1)
150 {
151 int32_t socketId;
152 EXPECT_EQ(dmTransport_->StartSocket("", socketId), ERR_DM_INPUT_PARA_INVALID);
153 }
154
155 /**
156 * @tc.name: StartSocket_ShouldReturnErrorIfAlreadyOpened
157 * @tc.type: FUNC
158 */
159 HWTEST_F(DMTransportTest, StartSocket_ShouldReturnErrorIfAlreadyOpened, testing::ext::TestSize.Level1)
160 {
161 int32_t socketId;
162 dmTransport_->StartSocket("device1", socketId);
163 EXPECT_EQ(dmTransport_->StartSocket("device1", socketId), ERR_DM_FAILED);
164 }
165
166 /**
167 * @tc.name: StopSocket_InvalidId_Failure
168 * @tc.type: FUNC
169 */
170 HWTEST_F(DMTransportTest, StopSocket_InvalidId_Failure, testing::ext::TestSize.Level1)
171 {
172 std::string invalidId = "invalidId";
173 int32_t result = dmTransport_->StopSocket(invalidId);
174 EXPECT_EQ(result, ERR_DM_FAILED);
175 }
176
177 /**
178 * @tc.name: StopSocket_SessionNotOpened_Failure
179 * @tc.type: FUNC
180 */
181 HWTEST_F(DMTransportTest, StopSocket_SessionNotOpened_Failure, testing::ext::TestSize.Level1)
182 {
183 std::string notOpenedId = "notOpenedId";
184 int32_t result = dmTransport_->StopSocket(notOpenedId);
185 EXPECT_EQ(result, ERR_DM_FAILED);
186 }
187
188 /**
189 * @tc.name: Send_InvalidId_Failure
190 * @tc.type: FUNC
191 */
192 HWTEST_F(DMTransportTest, Send_InvalidId_Failure, testing::ext::TestSize.Level1)
193 {
194 std::string invalidId = "invalidId";
195 std::string payload = "Hello, World!";
196 int32_t result = dmTransport_->Send(invalidId, payload, 0);
197 EXPECT_EQ(result, ERR_DM_FAILED);
198 }
199
200 /**
201 * @tc.name: Send_SessionNotOpened_Failure
202 * @tc.type: FUNC
203 */
204 HWTEST_F(DMTransportTest, Send_SessionNotOpened_Failure, testing::ext::TestSize.Level1)
205 {
206 std::string notOpenedId = "notOpenedId";
207 std::string payload = "Hello, World!";
208 int32_t result = dmTransport_->Send(notOpenedId, payload, 0);
209 EXPECT_EQ(result, ERR_DM_FAILED);
210 }
211
212 HWTEST_F(DMTransportTest, OnSocketOpened_001, testing::ext::TestSize.Level1)
213 {
214 int32_t socketId = 1;
215 std::string name = "socketName";
216 std::string networkId = "ne*****1v";
217 std::string pkgName = "ohos.objectstore";
218 PeerSocketInfo info = {
219 .name = name.data(),
220 .networkId = networkId.data(),
221 .pkgName = pkgName.data(),
222 .dataType = DATA_TYPE_BYTES
223 };
224 int32_t ret = dmTransport_->OnSocketOpened(socketId, info);
225 EXPECT_EQ(ret, DM_OK);
226
227 socketId = SOCKETED;
228 ret = dmTransport_->OnSocketOpened(socketId, info);
229 EXPECT_EQ(ret, DM_OK);
230 }
231
232 HWTEST_F(DMTransportTest, OnSocketClosed_001, testing::ext::TestSize.Level1)
233 {
234 int32_t socketId = 10;
235 std::string name = "socketName";
236 std::string networkId = "ne*****1v";
237 std::string pkgName = "ohos.objectstore";
238 PeerSocketInfo info = {
239 .name = name.data(),
240 .networkId = networkId.data(),
241 .pkgName = pkgName.data(),
242 .dataType = DATA_TYPE_BYTES
243 };
244 int32_t ret = dmTransport_->OnSocketOpened(socketId, info);
245 EXPECT_EQ(ret, DM_OK);
246
247 ShutdownReason reason = ShutdownReason::SHUTDOWN_REASON_LNN_CHANGED;
248 dmTransport_->OnSocketClosed(socketId, reason);
249
250 socketId = -1;
251 void *data = nullptr;
252 uint32_t dataLen = 0;
253 dmTransport_->OnBytesReceived(socketId, data, dataLen);
254 socketId = SOCKETED;
255 dmTransport_->OnBytesReceived(socketId, data, dataLen);
256 std::string dataStr = "a**************2";
257 data = reinterpret_cast<void *>(dataStr.data());
258 dataLen = static_cast<uint32_t>(dataStr.length());
259 dmTransport_->OnBytesReceived(socketId, data, dataLen);
260 socketId = 0;
261 dmTransport_->OnBytesReceived(socketId, data, dataLen);
262 std::string payload = "p*********13";
263 dmTransport_->HandleReceiveMessage(socketId, payload);
264 socketId = SOCKETED;
265 dmTransport_->HandleReceiveMessage(socketId, payload);
266 payload = R"({
267 "MsgType": "0",
268 "msg": "messgaeinfo",
269 "code": 145,
270 "userIds": [
271 {"type": 1, "userId": 111},
272 {"type": 0, "userId": 222}
273 ]
274 })";
275 dmTransport_->HandleReceiveMessage(socketId, payload);
276 }
277
278 HWTEST_F(DMTransportTest, CreateClientSocket_001, testing::ext::TestSize.Level1)
279 {
280 std::string rmtNetworkId = "";
281 int32_t ret = dmTransport_->CreateClientSocket(rmtNetworkId);
282 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
283
284 rmtNetworkId = "rmt**********7";
285 ret = dmTransport_->CreateClientSocket(rmtNetworkId);
286 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
287 }
288
289 HWTEST_F(DMTransportTest, IsDeviceSessionOpened_001, testing::ext::TestSize.Level1)
290 {
291 std::string rmtNetworkId = "";
292 int32_t socketId = 1;
293 bool ret = dmTransport_->IsDeviceSessionOpened(rmtNetworkId, socketId);
294 EXPECT_FALSE(ret);
295
296 rmtNetworkId = "rmt**********7";
297 ret = dmTransport_->IsDeviceSessionOpened(rmtNetworkId, socketId);
298 EXPECT_FALSE(ret);
299 }
300 } // DistributedHardware
301 } // OHOS