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