1 /**
2 * Copyright (c) 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 <arpa/inet.h>
17 #include <ctype.h>
18 #include <netinet/in.h>
19 #include <pthread.h>
20 #include <stdio.h>
21 #include <sys/socket.h>
22 #include <string.h>
23 #include <stdlib.h>
24 #include "functionalext.h"
25
26 typedef void (*TEST_FUN)();
27 #define BUF_SIZE (100)
28 #define PORT 2288
29 #define WAIT() pthread_barrier_wait(&g_barrier)
30 static const char *g_cliMsg = "Hello, this is client";
31 static const char *g_localHost = "127.0.0.1";
32 static pthread_barrier_t g_barrier;
33
SampleServerTask()34 void *SampleServerTask()
35 {
36 int *ret = (int *)malloc(sizeof(int));
37 int rets = -1;
38 int sListen = socket(AF_INET, SOCK_STREAM, 0);
39 if (sListen == -1) {
40 *ret = -1;
41 return ret;
42 }
43 int flag = 1;
44 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
45 struct sockaddr_in srvAddr = {0};
46 srvAddr.sin_family = AF_INET;
47 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
48 srvAddr.sin_port = htons(PORT);
49 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
50 if (rets != 0) {
51 close(sListen);
52 *ret = -1;
53 return ret;
54 }
55 rets = listen(sListen, 2);
56 if (rets != 0) {
57 close(sListen);
58 *ret = -1;
59 return ret;
60 }
61 WAIT();
62 struct sockaddr_in clnAddr = {0};
63 socklen_t clnAddrLen = sizeof(clnAddr);
64 int sClient = accept(sListen, (struct sockaddr *)&clnAddr, &clnAddrLen);
65 static char buf[BUF_SIZE + 1] = {0};
66 memset(buf, '\0', BUF_SIZE);
67 rets = recv(sClient, buf, sizeof(buf), 0);
68 close(sClient);
69 close(sListen);
70 return ret;
71 }
72
SampleClientTask()73 void *SampleClientTask()
74 {
75 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
76 WAIT();
77 struct sockaddr_in srvAddr = {0};
78 srvAddr.sin_family = AF_INET;
79 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
80 srvAddr.sin_port = htons(PORT);
81 int ret = connect(clnFd, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
82 EXPECT_EQ("send_0100", 0, ret);
83 static char buf[BUF_SIZE + 1] = {0};
84 memset(buf, '\0', BUF_SIZE);
85 strcpy(buf, g_cliMsg);
86 int sendRet = send(clnFd, buf, sizeof(buf), 0);
87 EXPECT_EQ("send_0100", sendRet, sizeof(buf));
88 close(clnFd);
89 return NULL;
90 }
91
SampleServerNullTask()92 void *SampleServerNullTask()
93 {
94 int *ret = (int *)malloc(sizeof(int));
95 int rets = 0;
96 int sListen = socket(AF_INET, SOCK_STREAM, 0);
97 if (sListen == -1) {
98 *ret = -1;
99 return ret;
100 }
101 int flag = 1;
102 rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
103 struct sockaddr_in srvAddr = {0};
104 srvAddr.sin_family = AF_INET;
105 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
106 srvAddr.sin_port = htons(PORT);
107 rets = bind(sListen, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
108 if (rets != 0) {
109 close(sListen);
110 *ret = -1;
111 return ret;
112 }
113 rets = listen(sListen, 2);
114 if (rets != 0) {
115 close(sListen);
116 *ret = -1;
117 return ret;
118 }
119 WAIT();
120 struct sockaddr_in clnAddr = {0};
121 socklen_t clnAddrLen = sizeof(clnAddr);
122 accept(sListen, (struct sockaddr *)&clnAddr, &clnAddrLen);
123 close(sListen);
124 return ret;
125 }
126
SampleClientNullTask()127 void *SampleClientNullTask()
128 {
129 int clnFd = socket(AF_INET, SOCK_STREAM, 0);
130 WAIT();
131 struct sockaddr_in srvAddr = {0};
132 srvAddr.sin_family = AF_INET;
133 srvAddr.sin_addr.s_addr = inet_addr(g_localHost);
134 srvAddr.sin_port = htons(PORT);
135 int ret = connect(clnFd, (struct sockaddr *)&srvAddr, sizeof(srvAddr));
136 EXPECT_EQ("send_0200", 0, ret);
137 static char buf[BUF_SIZE + 1] = {0};
138 memset(buf, '\0', BUF_SIZE);
139 strcpy(buf, g_cliMsg);
140 int result = send(clnFd, NULL, sizeof(buf), 0);
141 EXPECT_EQ("send_0200", result, -1);
142 return NULL;
143 }
144
145 /*
146 * @tc.name : send_0100
147 * @tc.desc : Verify that the client sent successfully
148 * @tc.level : Level 0
149 */
send_0100(void)150 void send_0100(void)
151 {
152 pthread_t srv;
153 pthread_t cli;
154 int ret = pthread_barrier_init(&g_barrier, 0, 2);
155 EXPECT_EQ("send_0100", 0, ret);
156 ret = pthread_create(&srv, NULL, SampleServerTask, NULL);
157 EXPECT_EQ("send_0100", 0, ret);
158 ret = pthread_create(&cli, NULL, SampleClientTask, NULL);
159 EXPECT_EQ("send_0100", 0, ret);
160 ret = pthread_join(cli, NULL);
161 EXPECT_EQ("send_0100", 0, ret);
162 ret = pthread_join(srv, NULL);
163 EXPECT_EQ("send_0100", 0, ret);
164 ret = pthread_barrier_destroy(&g_barrier);
165 EXPECT_EQ("send_0100", 0, ret);
166 }
167
168 /*
169 * @tc.name : send_0200
170 * @tc.desc : Verify that client send failed when parameter is invalid
171 * @tc.level : Level 2
172 */
send_0200(void)173 void send_0200(void)
174 {
175 pthread_t srv;
176 pthread_t cli;
177 int ret = pthread_barrier_init(&g_barrier, 0, 2);
178 EXPECT_EQ("send_0200", 0, ret);
179 ret = pthread_create(&srv, NULL, SampleServerNullTask, NULL);
180 EXPECT_EQ("send_0200", 0, ret);
181 ret = pthread_create(&cli, NULL, SampleClientNullTask, NULL);
182 EXPECT_EQ("send_0200", 0, ret);
183 ret = pthread_join(cli, NULL);
184 EXPECT_EQ("send_0200", 0, ret);
185 ret = pthread_join(srv, NULL);
186 EXPECT_EQ("send_0200", 0, ret);
187 ret = pthread_barrier_destroy(&g_barrier);
188 EXPECT_EQ("send_0200", 0, ret);
189 }
190
191 TEST_FUN G_Fun_Array[] = {send_0100, send_0200};
main(int argc,char * argv[])192 int main(int argc, char *argv[])
193 {
194 int num = sizeof(G_Fun_Array) / sizeof(TEST_FUN);
195 for (int pos = 0; pos < num; ++pos) {
196 G_Fun_Array[pos]();
197 }
198
199 return t_status;
200 }