1 /*
2 * Copyright (c) 2021-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 <gtest/gtest.h>
17 #include <cerrno>
18 #include <cstring>
19
20 #include "appspawn_socket.h"
21 #include "beget_ext.h"
22 #include "parameter.h"
23 #include "securec.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS::AppSpawn;
28
29 class AppSpawnSocketTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp();
34 void TearDown();
35 };
36
TearDownTestCase()37 void AppSpawnSocketTest::TearDownTestCase()
38 {}
39
SetUp()40 void AppSpawnSocketTest::SetUp()
41 {}
42
TearDown()43 void AppSpawnSocketTest::TearDown()
44 {}
45
46 /*
47 * Feature: AppSpawn
48 * Function: AppSpawnSocket
49 * SubFunction: CreateSocket & CloseSocket
50 * FunctionPoints: create socket and close socket.
51 * EnvConditions: mobile that can run ohos test framework
52 * CaseDescription: Verify if CreateSocket success then can close the socket.
53 */
54 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_001, TestSize.Level0)
55 {
56 GTEST_LOG_(INFO) << "App_Spawn_Socket_001 start";
57
58 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
59 EXPECT_TRUE(appSpawnSocket);
60
61 EXPECT_EQ(-1, appSpawnSocket->GetSocketFd());
62 auto socketFd = appSpawnSocket->CreateSocket();
63 EXPECT_LE(0, socketFd);
64 appSpawnSocket->CloseSocket(socketFd);
65 EXPECT_EQ(-1, socketFd);
66
67 GTEST_LOG_(INFO) << "App_Spawn_Socket_001 end";
68 }
69
70 /*
71 * Feature: AppSpawn
72 * Function: AppSpawnSocket
73 * SubFunction: CloseSocket
74 * FunctionPoints: close the invalid socket fd.
75 * EnvConditions: mobile that can run ohos test framework
76 * CaseDescription: Verify the function CloseSocket don't close the socket which socket fd is invalid.
77 */
78 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_002, TestSize.Level0)
79 {
80 GTEST_LOG_(INFO) << "App_Spawn_Socket_002 start";
81
82 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
83 EXPECT_TRUE(appSpawnSocket);
84
85 int32_t socketFd = -2;
86 appSpawnSocket->CloseSocket(socketFd);
87
88 EXPECT_EQ(-2, socketFd);
89
90 GTEST_LOG_(INFO) << "App_Spawn_Socket_002 end";
91 }
92
93 /*
94 * Feature: AppSpawn
95 * Function: AppSpawnSocket
96 * SubFunction: PackSocketAddr
97 * FunctionPoints: check the invalid socket name
98 * EnvConditions: mobile that can run ohos test framework
99 * CaseDescription: Verify the function PackSocketAddr can check the empty socket name.
100 */
101 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_003, TestSize.Level0)
102 {
103 GTEST_LOG_(INFO) << "App_Spawn_Socket_003 start";
104
105 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("");
106 EXPECT_TRUE(appSpawnSocket);
107
108 EXPECT_EQ(-EINVAL, appSpawnSocket->PackSocketAddr());
109
110 GTEST_LOG_(INFO) << "App_Spawn_Socket_003 end";
111 }
112
113 /*
114 * Feature: AppSpawn
115 * Function: AppSpawnSocket
116 * SubFunction: PackSocketAddr
117 * FunctionPoints: check the invalid socket name
118 * EnvConditions: mobile that can run ohos test framework
119 * CaseDescription: Verify the function PackSocketAddr can check too long socket name.
120 */
121 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_004, TestSize.Level0)
122 {
123 GTEST_LOG_(INFO) << "App_Spawn_Socket_004 start";
124
125 std::string invalidSocketName =
126 "InvalidInvalidInvalidInvalidInvalidInvalidInvalidInvalid"
127 "InvalidInvalidInvalidInvalidInvalidInvalidInvalidInvalidInvalidInvalidInvalidInvalid";
128 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>(invalidSocketName.c_str());
129 EXPECT_TRUE(appSpawnSocket);
130
131 EXPECT_EQ(-1, appSpawnSocket->PackSocketAddr());
132
133 GTEST_LOG_(INFO) << "App_Spawn_Socket_004 end";
134 }
135
136 /*
137 * Feature: AppSpawn
138 * Function: AppSpawnSocket
139 * SubFunction: PackSocketAddr
140 * FunctionPoints: pack socket address
141 * EnvConditions: mobile that can run ohos test framework
142 * CaseDescription: Verify the function PackSocketAddr can pack the socket address with valid socket name.
143 */
144 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_005, TestSize.Level0)
145 {
146 GTEST_LOG_(INFO) << "App_Spawn_Socket_005 start";
147
148 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
149 EXPECT_TRUE(appSpawnSocket);
150
151 EXPECT_EQ(0, appSpawnSocket->PackSocketAddr());
152
153 GTEST_LOG_(INFO) << "App_Spawn_Socket_005 end";
154 }
155
156 /*
157 * Feature: AppSpawn
158 * Function: AppSpawnSocket
159 * SubFunction: ReadSocketMessage
160 * FunctionPoints: check params
161 * EnvConditions: mobile that can run ohos test framework
162 * CaseDescription: Verify the function ReadSocketMessage can check the invalid socket fd.
163 */
164 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_006, TestSize.Level0)
165 {
166 GTEST_LOG_(INFO) << "App_Spawn_Socket_006 start";
167
168 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
169 EXPECT_TRUE(appSpawnSocket);
170
171 int32_t socketFd = -1;
172 std::unique_ptr<uint8_t[]> buff = std::make_unique<uint8_t[]>(10);
173 EXPECT_TRUE(buff);
174 int32_t len = 10;
175
176 EXPECT_EQ(-1, appSpawnSocket->ReadSocketMessage(socketFd, buff.get(), len));
177
178 GTEST_LOG_(INFO) << "App_Spawn_Socket_006 end";
179 }
180
181 /*
182 * Feature: AppSpawn
183 * Function: AppSpawnSocket
184 * SubFunction: ReadSocketMessage
185 * FunctionPoints: check params
186 * EnvConditions: mobile that can run ohos test framework
187 * CaseDescription: Verify the function ReadSocketMessage can check the invalid buffer pointer.
188 */
189 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_007, TestSize.Level0)
190 {
191 GTEST_LOG_(INFO) << "App_Spawn_Socket_007 start";
192
193 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
194 EXPECT_TRUE(appSpawnSocket);
195 auto socketFd = appSpawnSocket->CreateSocket();
196 std::unique_ptr<uint8_t[]> buff = nullptr;
197 int32_t len = 10;
198
199 EXPECT_EQ(-1, appSpawnSocket->ReadSocketMessage(socketFd, buff.get(), len));
200 appSpawnSocket->CloseSocket(socketFd);
201
202 GTEST_LOG_(INFO) << "App_Spawn_Socket_007 end";
203 }
204
205 /*
206 * Feature: AppSpawn
207 * Function: AppSpawnSocket
208 * SubFunction: ReadSocketMessage
209 * FunctionPoints: check params
210 * EnvConditions: mobile that can run ohos test framework
211 * CaseDescription: Verify the function ReadSocketMessage can check the buffer length is 0.
212 */
213 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_008, TestSize.Level0)
214 {
215 GTEST_LOG_(INFO) << "App_Spawn_Socket_008 start";
216
217 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
218 EXPECT_TRUE(appSpawnSocket);
219 auto socketFd = appSpawnSocket->CreateSocket();
220 std::unique_ptr<uint8_t[]> buff = std::make_unique<uint8_t[]>(10);
221 EXPECT_TRUE(buff);
222 int32_t len = 0;
223
224 EXPECT_EQ(-1, appSpawnSocket->ReadSocketMessage(socketFd, buff.get(), len));
225 appSpawnSocket->CloseSocket(socketFd);
226
227 GTEST_LOG_(INFO) << "App_Spawn_Socket_008 end";
228 }
229
230 /*
231 * Feature: AppSpawn
232 * Function: AppSpawnSocket
233 * SubFunction: ReadSocketMessage
234 * FunctionPoints: check params
235 * EnvConditions: mobile that can run ohos test framework
236 * CaseDescription: Verify the function ReadSocketMessage can check the buffer length < 0.
237 */
238 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_009, TestSize.Level0)
239 {
240 GTEST_LOG_(INFO) << "App_Spawn_Socket_009 start";
241
242 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
243 EXPECT_TRUE(appSpawnSocket);
244 auto socketFd = appSpawnSocket->CreateSocket();
245 std::unique_ptr<uint8_t[]> buff = std::make_unique<uint8_t[]>(10);
246 EXPECT_TRUE(buff);
247 int32_t len = -1;
248
249 EXPECT_EQ(-1, appSpawnSocket->ReadSocketMessage(socketFd, buff.get(), len));
250 appSpawnSocket->CloseSocket(socketFd);
251
252 GTEST_LOG_(INFO) << "App_Spawn_Socket_009 end";
253 }
254
255 /*
256 * Feature: AppSpawn
257 * Function: AppSpawnSocket
258 * SubFunction: ReadSocketMessage
259 * FunctionPoints: normal read data
260 * EnvConditions: mobile that can run ohos test framework
261 * CaseDescription: Verify the function ReadSocketMessage can read the normal message.
262 */
263 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_010, TestSize.Level0)
264 {
265 GTEST_LOG_(INFO) << "App_Spawn_Socket_010 start";
266
267 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
268 EXPECT_TRUE(appSpawnSocket);
269 std::string content = "hiworld";
270 int32_t len = content.length();
271 EXPECT_TRUE(len);
272 std::unique_ptr<int8_t[]> buff = std::make_unique<int8_t[]>(len);
273 EXPECT_TRUE(buff);
274 int32_t fd[2] = {0, 0};
275
276 if (pipe(fd) == -1) {
277 GTEST_LOG_(WARNING) << "create pipe fail";
278 return;
279 }
280 write(fd[1], content.c_str(), len);
281
282 EXPECT_EQ(len, appSpawnSocket->ReadSocketMessage(fd[0], buff.get(), len));
283 EXPECT_EQ(0, strncmp(content.c_str(), reinterpret_cast<const char *>(buff.get()), len));
284
285 // close pipe
286 close(fd[0]);
287 close(fd[1]);
288
289 GTEST_LOG_(INFO) << "App_Spawn_Socket_010 end";
290 }
291
292 /*
293 * Feature: AppSpawn
294 * Function: AppSpawnSocket
295 * SubFunction: WriteSocketMessage
296 * FunctionPoints: check params
297 * EnvConditions: mobile that can run ohos test framework
298 * CaseDescription: Verify the function WriteSocketMessage can check the invalid socket fd.
299 */
300 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_011, TestSize.Level0)
301 {
302 GTEST_LOG_(INFO) << "App_Spawn_Socket_011 start";
303
304 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
305 EXPECT_TRUE(appSpawnSocket);
306 int32_t socketFd = -1;
307 std::string buff = "hiworld";
308
309 EXPECT_EQ(-1, appSpawnSocket->WriteSocketMessage(socketFd, buff.c_str(), buff.length()));
310
311 GTEST_LOG_(INFO) << "App_Spawn_Socket_011 end";
312 }
313
314 /*
315 * Feature: AppSpawn
316 * Function: AppSpawnSocket
317 * SubFunction: WriteSocketMessage
318 * FunctionPoints: check params
319 * EnvConditions: mobile that can run ohos test framework
320 * CaseDescription: Verify the function ReadSocketMessage can check the invalid buffer pointer.
321 */
322 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_012, TestSize.Level0)
323 {
324 GTEST_LOG_(INFO) << "App_Spawn_Socket_012 start";
325
326 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
327 EXPECT_TRUE(appSpawnSocket);
328 auto socketFd = appSpawnSocket->CreateSocket();
329 std::unique_ptr<uint8_t[]> buff = nullptr;
330 int32_t len = 10;
331
332 EXPECT_EQ(-1, appSpawnSocket->WriteSocketMessage(socketFd, buff.get(), len));
333 appSpawnSocket->CloseSocket(socketFd);
334
335 GTEST_LOG_(INFO) << "App_Spawn_Socket_012 end";
336 }
337
338 /*
339 * Feature: AppSpawn
340 * Function: AppSpawnSocket
341 * SubFunction: WriteSocketMessage
342 * FunctionPoints: check params
343 * EnvConditions: mobile that can run ohos test framework
344 * CaseDescription: Verify the function ReadSocketMessage can check the buffer length is 0.
345 */
346 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_013, TestSize.Level0)
347 {
348 GTEST_LOG_(INFO) << "App_Spawn_Socket_013 start";
349
350 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
351 EXPECT_TRUE(appSpawnSocket);
352 auto socketFd = appSpawnSocket->CreateSocket();
353 std::string buff = "hiworld";
354 int32_t len = 0;
355
356 EXPECT_EQ(-1, appSpawnSocket->WriteSocketMessage(socketFd, buff.c_str(), len));
357 appSpawnSocket->CloseSocket(socketFd);
358
359 GTEST_LOG_(INFO) << "App_Spawn_Socket_013 end";
360 }
361
362 /*
363 * Feature: AppSpawn
364 * Function: AppSpawnSocket
365 * SubFunction: WriteSocketMessage
366 * FunctionPoints: check params
367 * EnvConditions: mobile that can run ohos test framework
368 * CaseDescription: Verify the function ReadSocketMessage can check the buffer length < 0.
369 */
370 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_014, TestSize.Level0)
371 {
372 GTEST_LOG_(INFO) << "App_Spawn_Socket_014 start";
373
374 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
375 EXPECT_TRUE(appSpawnSocket);
376 auto socketFd = appSpawnSocket->CreateSocket();
377 std::string buff = "hiworld";
378 int32_t len = -1;
379
380 EXPECT_EQ(-1, appSpawnSocket->WriteSocketMessage(socketFd, buff.c_str(), len));
381 appSpawnSocket->CloseSocket(socketFd);
382
383 GTEST_LOG_(INFO) << "App_Spawn_Socket_014 end";
384 }
385
386 /*
387 * Feature: AppSpawn
388 * Function: AppSpawnSocket
389 * SubFunction: WriteSocketMessage
390 * FunctionPoints: normal write data
391 * EnvConditions: mobile that can run ohos test framework
392 * CaseDescription: Verify the function WriteSocketMessage can write the normal message.
393 */
394 HWTEST(AppSpawnSocketTest, App_Spawn_Socket_015, TestSize.Level0)
395 {
396 GTEST_LOG_(INFO) << "App_Spawn_Socket_015 start";
397
398 std::unique_ptr<AppSpawnSocket> appSpawnSocket = std::make_unique<AppSpawnSocket>("AppSpawnSocketTest");
399 EXPECT_TRUE(appSpawnSocket);
400 std::string content = "hiworld";
401 int32_t len = content.length();
402 EXPECT_TRUE(len);
403 std::unique_ptr<int8_t[]> buff = std::make_unique<int8_t[]>(len);
404 EXPECT_TRUE(buff);
405 int32_t fd[2] = {0, 0};
406
407 if (pipe(fd) == -1) {
408 GTEST_LOG_(WARNING) << "create pipe fail";
409 return;
410 }
411
412 EXPECT_EQ(len, appSpawnSocket->WriteSocketMessage(fd[1], content.c_str(), len));
413 read(fd[0], buff.get(), len);
414 EXPECT_EQ(0, strncmp(content.c_str(), reinterpret_cast<const char *>(buff.get()), len));
415
416 // close pipe
417 close(fd[0]);
418 close(fd[1]);
419
420 GTEST_LOG_(INFO) << "App_Spawn_Socket_015 end";
421 }
422