1 /*
2 * Copyright (c) 2021 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 "IpcMqTest.h"
17 #include <stdio.h>
18 #include <mqueue.h>
19 #include <fcntl.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #include "log.h"
23 #include "utils.h"
24 #include "KernelConstants.h"
25 #include <securec.h>
26
27 using namespace testing::ext;
28
29 /* *
30 * @tc.number SUB_KERNEL_IPC_MQ_OPEN_0100
31 * @tc.name mq_open function errno for EEXIST test
32 * @tc.desc [C- SOFTWARE -0200]
33 */
HWTEST_F(IpcMqTest, testMqOpenEEXIST, Function | MediumTest | Level2)34 HWTEST_F(IpcMqTest, testMqOpenEEXIST, Function | MediumTest | Level2)
35 {
36 char qName[MQ_NAME_LEN];
37 mqd_t queue, queueOther;
38
39 sprintf_s(qName, sizeof(qName), "testMqOpenEEXIST_%d", GetRandom(10000));
40 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
41 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
42
43 queueOther = mq_open(qName, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, NULL);
44 EXPECT_TRUE(queueOther == (mqd_t)-1) << "ERROR: mq_open() != (mqd_t)-1, queueOther = " << queueOther;
45 EXPECT_TRUE(errno == EEXIST) << "ERROR: errno != EEXIST"
46 << " errno = " << errno << " strerror(errno) = " << strerror(errno);
47 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
48 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
49 }
50
51 /* *
52 * @tc.number SUB_KERNEL_IPC_MQ_OPEN_0200
53 * @tc.name mq_open function errno for EINVAL test
54 * @tc.desc [C- SOFTWARE -0200]
55 */
HWTEST_F(IpcMqTest, testMqOpenEINVAL, Function | MediumTest | Level2)56 HWTEST_F(IpcMqTest, testMqOpenEINVAL, Function | MediumTest | Level2)
57 {
58 int i;
59 mqd_t queue;
60 struct mq_attr attr = { 0 };
61 char qName[MQ_NAME_LEN];
62 const int max = 65535;
63
64 sprintf_s(qName, sizeof(qName), "testMqOpenEINVAL_%d", GetRandom(10000));
65
66 for (i = 0; i < 6; i++) {
67 switch (i) {
68 case 0:
69 attr.mq_msgsize = -1;
70 attr.mq_maxmsg = max;
71 break;
72 case 1:
73 /* attr.mq_msgsize > USHRT_MAX - 4 */
74 attr.mq_msgsize = max;
75 attr.mq_maxmsg = max;
76 break;
77 case 2:
78 attr.mq_msgsize = 10;
79 attr.mq_maxmsg = -1;
80 break;
81 case 3:
82 attr.mq_msgsize = 10;
83 attr.mq_maxmsg = max + 1;
84 break;
85
86 case 4:
87 attr.mq_msgsize = 0;
88 attr.mq_maxmsg = 16;
89 break;
90
91 case 5:
92 attr.mq_msgsize = 64;
93 attr.mq_maxmsg = 0;
94 break;
95 }
96
97 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
98 EXPECT_TRUE(queue == (mqd_t)-1) << "ERROR: mq_open() != (mqd_t)-1, i = " << i;
99
100 if (queue != (mqd_t)-1) {
101 mq_close(queue);
102 mq_unlink(qName);
103 }
104
105 /* if NOT call mq_close & mq_unlink then errno == ENOENT */
106 EXPECT_TRUE(errno == EINVAL) << "errno != EINVAL, errno = " << errno << " i = " << i << " qName = " << qName;
107 }
108
109 for (i = 0; i < MQ_NAME_LEN; i++) {
110 qName[i] = 0;
111 }
112 attr.mq_msgsize = MQ_MSG_SIZE;
113 attr.mq_maxmsg = MQ_MAX_MSG;
114 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
115 EXPECT_TRUE(errno == EINVAL) << "errno != EINVAL, errno = " << errno << " i = " << i << " qName = " << qName;
116 }
117
118 /* *
119 * @tc.number SUB_KERNEL_IPC_MQ_OPEN_0300
120 * @tc.name mq_open function errno for ENAMETOOLONG test
121 * @tc.desc [C- SOFTWARE -0200]
122 */
HWTEST_F(IpcMqTest, testMqOpenENAMETOOLONG, Function | MediumTest | Level2)123 HWTEST_F(IpcMqTest, testMqOpenENAMETOOLONG, Function | MediumTest | Level2)
124 {
125 char qName[MAX_MQ_NAME_LEN + 10];
126 mqd_t queue;
127 int i;
128
129 for (i = 0; i < MAX_MQ_NAME_LEN + 5; i++) {
130 qName[i] = '8';
131 }
132 qName[i] = '\0';
133
134 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
135 EXPECT_TRUE(queue == (mqd_t)-1) << "ERROR: mq_open() != (mqd_t)-1 ";
136
137 if (queue != (mqd_t)-1) {
138 mq_close(queue);
139 mq_unlink(qName);
140 }
141
142 ASSERT_TRUE(errno == ENAMETOOLONG) << "errno != ENAMETOOLONG, errno = " << errno;
143 }
144
145 /* *
146 * @tc.number SUB_KERNEL_IPC_MQ_OPEN_0400
147 * @tc.name mq_open function errno for ENOENT test
148 * @tc.desc [C- SOFTWARE -0200]
149 */
HWTEST_F(IpcMqTest, testMqOpenENOENT, Function | MediumTest | Level3)150 HWTEST_F(IpcMqTest, testMqOpenENOENT, Function | MediumTest | Level3)
151 {
152 mqd_t queue;
153 char qName[MQ_NAME_LEN];
154
155 sprintf(qName, "testMqOpenENOENT_%d", GetRandom(10000));
156 queue = mq_open(qName, O_RDWR, S_IRUSR | S_IWUSR, NULL);
157 EXPECT_TRUE(queue == (mqd_t)-1) << "ERROR: mq_open() != (mqd_t)-1 ";
158
159 if (queue != (mqd_t)-1) {
160 mq_close(queue);
161 mq_unlink(qName);
162 }
163 ASSERT_TRUE(errno == ENOENT) << "errno != ENOENT, errno = " << errno;
164 }
165
166 /* *
167 * @tc.number SUB_KERNEL_IPC_MQ_OPEN_0500
168 * @tc.name mq_open function errno for ENFILE test
169 * @tc.desc [C- SOFTWARE -0200]
170 */
HWTEST_F(IpcMqTest, testMqOpenENFILE, Function | MediumTest | Level3)171 HWTEST_F(IpcMqTest, testMqOpenENFILE, Function | MediumTest | Level3)
172 {
173 char qName[MAX_MQ_NUMBER + 1][30];
174 mqd_t queue[MAX_MQ_NUMBER + 1];
175 int flag = 0;
176 int i;
177 for (i = 0; i < MAX_MQ_NUMBER + 1; i++) {
178 sprintf(qName[i], "testMqOpenENFILE_%d", i);
179 }
180
181 for (i = 0; i < MAX_MQ_NUMBER; i++) {
182 queue[i] = mq_open(qName[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
183
184 if (queue[i] == (mqd_t)-1) {
185 flag = 1;
186 LOG("break: i = %d", i);
187 break;
188 }
189
190 EXPECT_TRUE(queue[i] != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1, i = " << i << " errno = " << errno <<
191 " strerror(errno) = " << strerror(errno);
192 }
193
194 LOG("func: i = %d", i);
195 if (flag == 0) {
196 queue[i] = mq_open(qName[i], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
197 }
198 EXPECT_TRUE(queue[i] == (mqd_t)-1) << "ERROR: mq_open() != (mqd_t)-1, i = " << i << " queue = " << queue[i] <<
199 " errno = " << errno << " strerror(errno) = " << strerror(errno);
200 EXPECT_TRUE(errno == ENFILE) << "ERROR: errno != ENFILE, i = " << i << " errno = " << errno <<
201 " strerror(errno) = " << strerror(errno);
202
203 for (i = 0; i < MAX_MQ_NUMBER + 1; i++) {
204 mq_close(queue[i]);
205 mq_unlink(qName[i]);
206 }
207 }
208
209 /* *
210 * @tc.number SUB_KERNEL_IPC_MQ_OPEN_0600
211 * @tc.name mq_open function errno for ENOSPC test
212 * @tc.desc [C- SOFTWARE -0200]
213 */
HWTEST_F(IpcMqTest, testMqOpenENOSPC, Function | MediumTest | Level3)214 HWTEST_F(IpcMqTest, testMqOpenENOSPC, Function | MediumTest | Level3)
215 {
216 mqd_t queue;
217 struct mq_attr setAttr = { 0 };
218 char qName[MQ_NAME_LEN];
219
220 sprintf(qName, "testMqOpenENOSPC_%d", GetRandom(10000));
221 setAttr.mq_msgsize = MAX_MQ_MSG_SIZE + 1;
222 setAttr.mq_maxmsg = MAX_MQ_NAME_LEN;
223 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
224 EXPECT_TRUE(queue == (mqd_t)-1) << "ERROR: mq_open() != (mqd_t)-1 ";
225
226 if (queue != (mqd_t)-1) {
227 mq_close(queue);
228 mq_unlink(qName);
229 }
230 ASSERT_TRUE(errno == ENOSPC) << "errno != ENOSPC, errno = " << errno;
231 }
232
233 /* *
234 * @tc.number SUB_KERNEL_IPC_MQ_CLOSE_0100
235 * @tc.name mq_close function errno for EBADF test
236 * @tc.desc [C- SOFTWARE -0200]
237 */
HWTEST_F(IpcMqTest, testMqCloseEBADF, Function | MediumTest | Level2)238 HWTEST_F(IpcMqTest, testMqCloseEBADF, Function | MediumTest | Level2)
239 {
240 ASSERT_TRUE(mq_close(0) == -1) << "ERROR: mq_close() != -1";
241 ASSERT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
242 }
243
244 /* *
245 * @tc.number SUB_KERNEL_IPC_MQ_SEND_0100
246 * @tc.name mq_send function errno for EAGAIN test
247 * @tc.desc [C- SOFTWARE -0200]
248 */
HWTEST_F(IpcMqTest, testMqSendEAGAIN, Function | MediumTest | Level2)249 HWTEST_F(IpcMqTest, testMqSendEAGAIN, Function | MediumTest | Level2)
250 {
251 mqd_t queue;
252 struct mq_attr attr = { 0 };
253 char qName[MQ_NAME_LEN];
254
255 sprintf(qName, "testMqSendEAGAIN_%d", GetRandom(10000));
256 attr.mq_msgsize = MQ_MSG_SIZE;
257 attr.mq_maxmsg = 1;
258 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
259 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
260
261 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, 0) == 0) << "ERROR: mq_send() != 0";
262 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, 0) == -1) << "ERROR: mq_send() != -1";
263 EXPECT_TRUE(errno == EAGAIN) << "ERROR: errno != EAGAIN, errno = " << errno << " EAGAIN = " << EAGAIN;
264
265 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
266 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
267 }
268
269 /* *
270 * @tc.number SUB_KERNEL_IPC_MQ_SEND_0200
271 * @tc.name mq_send function errno for EBADF and EMSGSIZE test
272 * @tc.desc [C- SOFTWARE -0200]
273 */
HWTEST_F(IpcMqTest, testMqSendEBADFEMSGSIZE, Function | MediumTest | Level2)274 HWTEST_F(IpcMqTest, testMqSendEBADFEMSGSIZE, Function | MediumTest | Level2)
275 {
276 mqd_t queue;
277 struct mq_attr attr = { 0 };
278 char qName[MQ_NAME_LEN];
279
280 sprintf(qName, "testMqSendEAGAIN_%d", GetRandom(10000));
281 attr.mq_msgsize = 1;
282 attr.mq_maxmsg = MQ_MAX_MSG;
283 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
284 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
285
286 EXPECT_TRUE(mq_send(0, MQ_MSG, 1, MQ_MSG_PRIO) == -1) << "ERROR: mq_send() != -1";
287 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
288
289 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == -1) << "ERROR: mq_send() != -1";
290 EXPECT_TRUE(errno == EMSGSIZE) << "ERROR: errno != EMSGSIZE, errno = " << errno << " EMSGSIZE = " << EMSGSIZE;
291
292 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
293 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
294
295 attr.mq_msgsize = MQ_MSG_SIZE;
296 attr.mq_maxmsg = MQ_MAX_MSG;
297 queue = mq_open(qName, O_CREAT | O_RDONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
298 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
299
300 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == -1) << "ERROR: mq_send() != -1";
301 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
302
303 attr.mq_flags |= O_NONBLOCK;
304 EXPECT_TRUE(mq_setattr(queue, &attr, NULL) == 0) << "ERROR: mq_setattr() != 0";
305 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == -1) << "ERROR: mq_send() != -1";
306 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
307
308 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
309 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
310 }
311
312 /* *
313 * @tc.number SUB_KERNEL_IPC_MQ_SEND_0300
314 * @tc.name mq_send function errno for EINVAL test
315 * @tc.desc [C- SOFTWARE -0200]
316 */
HWTEST_F(IpcMqTest, testMqSendEINVAL, Function | MediumTest | Level3)317 HWTEST_F(IpcMqTest, testMqSendEINVAL, Function | MediumTest | Level3)
318 {
319 mqd_t queue;
320 struct mq_attr attr = { 0 };
321 char qName[MQ_NAME_LEN];
322
323 sprintf(qName, "testMqSendEINVAL_%d", GetRandom(10000));
324 attr.mq_msgsize = MQ_MSG_SIZE;
325 attr.mq_maxmsg = MQ_MAX_MSG;
326 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
327 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
328
329 EXPECT_TRUE(mq_send(queue, MQ_MSG, 0, MQ_MSG_PRIO) == -1) << "ERROR: mq_send() != -1";
330 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL;
331
332 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
333 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
334 }
335
336 /* *
337 * @tc.number SUB_KERNEL_IPC_MQ_RECEIVE_0100
338 * @tc.name mq_receive function errno for EAGAIN test
339 * @tc.desc [C- SOFTWARE -0200]
340 */
HWTEST_F(IpcMqTest, testMqReceiveEAGAIN, Function | MediumTest | Level2)341 HWTEST_F(IpcMqTest, testMqReceiveEAGAIN, Function | MediumTest | Level2)
342 {
343 mqd_t queue;
344 unsigned int prio;
345 struct mq_attr attr = { 0 };
346 struct mq_attr getAttr = { 0 };
347 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
348
349 sprintf(qName, "testMqReceiveEAGAIN_%d", GetRandom(10000));
350 attr.mq_msgsize = MQ_MSG_SIZE;
351 attr.mq_maxmsg = MQ_MAX_MSG;
352 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
353 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
354
355 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
356 EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
357 EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
358 EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
359 EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "ERROR: strncmp() != 0, sent != received: sent = " <<
360 MQ_MSG << ", received = " << rMsg;
361 EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) == -1) << "ERROR: mq_receive() != -1";
362 EXPECT_TRUE(errno == EAGAIN) << "ERROR: errno != EAGAIN, errno = " << errno << " EAGAIN = " << EAGAIN;
363
364 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
365 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
366 }
367
368 /* *
369 * @tc.number SUB_KERNEL_IPC_MQ_RECEIVE_0200
370 * @tc.name mq_receive function errno for EBADF and EMSGSIZE test
371 * @tc.desc [C- SOFTWARE -0200]
372 */
HWTEST_F(IpcMqTest, testMqReceiveEBADFEMSGSIZE, Function | MediumTest | Level2)373 HWTEST_F(IpcMqTest, testMqReceiveEBADFEMSGSIZE, Function | MediumTest | Level2)
374 {
375 mqd_t queue;
376 unsigned int prio;
377 struct mq_attr attr = { 0 };
378 struct mq_attr getAttr = { 0 };
379 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN], rMsgErr[1];
380
381 sprintf(qName, "testMqReceiveEAGAIN_%d", GetRandom(10000));
382 attr.mq_msgsize = MQ_MSG_SIZE;
383 attr.mq_maxmsg = MQ_MAX_MSG;
384 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
385 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
386
387 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
388 EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
389 EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
390 EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "ERROR: strncmp() != 0, sent != received: sent = " <<
391 MQ_MSG << ", received = " << rMsg;
392
393 EXPECT_TRUE(mq_receive(0, rMsg, getAttr.mq_msgsize, &prio) == -1) << "ERROR: mq_receive() != -1";
394 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
395
396 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
397 EXPECT_TRUE(mq_receive(queue, rMsgErr, sizeof(rMsgErr), &prio) == -1) << "ERROR: mq_receive() != -1";
398 EXPECT_TRUE(errno == EMSGSIZE) << "ERROR: errno != EMSGSIZE, errno = " << errno << " EMSGSIZE = " << EMSGSIZE;
399
400 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
401 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
402
403 attr.mq_msgsize = MQ_MSG_SIZE;
404 attr.mq_maxmsg = MQ_MAX_MSG;
405 queue = mq_open(qName, O_CREAT | O_WRONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
406 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
407
408 EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) == -1) << "ERROR: mq_receive() != -1";
409 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
410
411 attr.mq_flags |= O_NONBLOCK;
412 EXPECT_TRUE(mq_setattr(queue, &attr, NULL) == 0) << "ERROR: mq_setattr() != 0";
413 EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) == -1) << "ERROR: mq_receive() != -1";
414 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
415
416 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
417 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
418 }
419
420 /* *
421 * @tc.number SUB_KERNEL_IPC_MQ_RECEIVE_0300
422 * @tc.name mq_receive function errno for EINVAL test
423 * @tc.desc [C- SOFTWARE -0200]
424 */
HWTEST_F(IpcMqTest, testMqReceiveEINVAL, Function | MediumTest | Level3)425 HWTEST_F(IpcMqTest, testMqReceiveEINVAL, Function | MediumTest | Level3)
426 {
427 mqd_t queue;
428 unsigned int prio;
429 struct mq_attr attr = { 0 };
430 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
431
432 sprintf(qName, "testMqReceiveEINVAL_%d", GetRandom(10000));
433 attr.mq_msgsize = MQ_MSG_SIZE;
434 attr.mq_maxmsg = MQ_MAX_MSG;
435 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
436 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
437
438 EXPECT_TRUE(mq_receive(queue, rMsg, 0, &prio) == -1) << "ERROR: mq_receive() != -1";
439 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL;
440
441 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
442 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
443 }
444
445 /* *
446 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0100
447 * @tc.name mq_timedsend function errno for EAGAIN and EBADF test
448 * @tc.desc [C- SOFTWARE -0200]
449 */
HWTEST_F(IpcMqTest, testMqTimedSendEAGAINEBADF, Function | MediumTest | Level2)450 HWTEST_F(IpcMqTest, testMqTimedSendEAGAINEBADF, Function | MediumTest | Level2)
451 {
452 mqd_t queue;
453 struct timespec ts = { 0, 0 };
454 struct mq_attr attr = { 0 };
455 char qName[MQ_NAME_LEN];
456
457 sprintf(qName, "testMqTimedSendEAGAIN_%d", GetRandom(10000));
458 attr.mq_msgsize = MQ_MSG_SIZE;
459 attr.mq_maxmsg = 1;
460 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
461 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
462
463 ts.tv_sec = time(NULL) + 1;
464 ts.tv_nsec = 0;
465 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == 0) << "ERROR: mq_timedsend() != 0";
466
467 ts.tv_sec = 0;
468 ts.tv_nsec = 0;
469 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != 0";
470 EXPECT_TRUE(errno == EAGAIN) << "ERROR: errno != EAGAIN, errno = " << errno << " EAGAIN = " << EAGAIN;
471
472 EXPECT_TRUE(mq_timedsend(0, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != -1";
473 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
474
475 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
476 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
477
478 attr.mq_msgsize = MQ_MSG_SIZE;
479 attr.mq_maxmsg = MQ_MAX_MSG;
480 queue = mq_open(qName, O_CREAT | O_RDONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
481 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
482
483 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != -1";
484 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
485
486 attr.mq_flags |= O_NONBLOCK;
487 EXPECT_TRUE(mq_setattr(queue, &attr, NULL) == 0) << "ERROR: mq_setattr() != 0";
488 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != -1";
489 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
490
491 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
492 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
493 }
494
495 /* *
496 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0200
497 * @tc.name mq_timedsend function errno for EINVAL test
498 * @tc.desc [C- SOFTWARE -0200]
499 */
HWTEST_F(IpcMqTest, testMqTimedSendEINVAL, Function | MediumTest | Level2)500 HWTEST_F(IpcMqTest, testMqTimedSendEINVAL, Function | MediumTest | Level2)
501 {
502 mqd_t queue;
503 int i;
504 struct timespec ts = { 0, 0 };
505 struct mq_attr attr = { 0 };
506 char qName[MQ_NAME_LEN];
507
508 sprintf(qName, "testMqTimedSendEINVAL_%d", GetRandom(10000));
509 attr.mq_msgsize = MQ_MSG_SIZE;
510 attr.mq_maxmsg = MQ_MAX_MSG;
511 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
512 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
513
514 for (i = 0; i < 3; i++) {
515 switch (i) {
516 case 0:
517 ts.tv_sec = -1;
518 ts.tv_nsec = 0;
519 break;
520 case 1:
521 ts.tv_sec = time(NULL) + 1;
522 ts.tv_nsec = -1;
523 break;
524 case 2:
525 ts.tv_sec = time(NULL) + 1;
526 ts.tv_nsec = 1000000000UL + 1UL;
527 break;
528 }
529
530 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) <<
531 "ERROR: mq_timedsend() != -1, i = " << i;
532 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL <<
533 " i = " << i;
534 }
535
536 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, 0, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != -1";
537 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL;
538
539 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
540 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
541 }
542
543 /* *
544 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0300
545 * @tc.name mq_timedsend function errno for EMSGSIZE test
546 * @tc.desc [C- SOFTWARE -0200]
547 */
HWTEST_F(IpcMqTest, testMqTimedSendEMSGSIZE, Function | MediumTest | Level3)548 HWTEST_F(IpcMqTest, testMqTimedSendEMSGSIZE, Function | MediumTest | Level3)
549 {
550 mqd_t queue;
551 struct timespec ts = { 0, 0 };
552 struct mq_attr attr = { 0 };
553 char qName[MQ_NAME_LEN];
554
555 sprintf(qName, "testMqTimedSendEMSGSIZE_%d", GetRandom(10000));
556 attr.mq_msgsize = 1;
557 attr.mq_maxmsg = MQ_MAX_MSG;
558 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
559 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
560
561 ts.tv_sec = time(NULL) + 1;
562 ts.tv_nsec = 0;
563 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != -1";
564 EXPECT_TRUE(errno == EMSGSIZE) << "ERROR: errno != EMSGSIZE, errno = " << errno << " EMSGSIZE = " << EMSGSIZE;
565
566 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
567 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
568 }
569
570 /* *
571 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0400
572 * @tc.name mq_timedsend function errno for ETIMEDOUT test
573 * @tc.desc [C- SOFTWARE -0200]
574 */
HWTEST_F(IpcMqTest, testMqTimedSendETIMEDOUT, Function | MediumTest | Level3)575 HWTEST_F(IpcMqTest, testMqTimedSendETIMEDOUT, Function | MediumTest | Level3)
576 {
577 mqd_t queue;
578 struct timespec ts = { 0, 0 };
579 struct mq_attr attr = { 0 };
580 char qName[MQ_NAME_LEN];
581
582 sprintf(qName, "testMqTimedSendETIMEDOUT_%d", GetRandom(10000));
583 attr.mq_msgsize = MQ_MSG_SIZE;
584 attr.mq_maxmsg = 1;
585 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
586 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
587
588 ts.tv_sec = time(NULL) + 1;
589 ts.tv_nsec = 0;
590 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == 0) << "ERROR: mq_timedsend() != 0";
591
592 ts.tv_sec = 0;
593 ts.tv_nsec = 100;
594 EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts) == -1) << "ERROR: mq_timedsend() != -1";
595 EXPECT_TRUE(errno == ETIMEDOUT) << "ERROR: errno != ETIMEDOUT, errno = " << errno << " ETIMEDOUT = " << ETIMEDOUT;
596
597 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
598 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
599 }
600
601 /* *
602 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0100
603 * @tc.name mq_timedreceive function errno for EAGAIN and EBADF test
604 * @tc.desc [C- SOFTWARE -0200]
605 */
HWTEST_F(IpcMqTest, testMqTimedReceiveEAGAINEBADF, Function | MediumTest | Level2)606 HWTEST_F(IpcMqTest, testMqTimedReceiveEAGAINEBADF, Function | MediumTest | Level2)
607 {
608 mqd_t queue;
609 unsigned int prio;
610 struct timespec ts = { 0, 0 };
611 struct mq_attr attr = { 0 };
612 struct mq_attr getAttr = { 0 };
613 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
614
615 sprintf(qName, "testMqTimedReceiveEAGAIN_%d", GetRandom(10000));
616 attr.mq_msgsize = MQ_MSG_SIZE;
617 attr.mq_maxmsg = MQ_MAX_MSG;
618 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
619 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
620
621 EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
622 ts.tv_sec = time(NULL) + 1;
623 ts.tv_nsec = 0;
624 EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
625 EXPECT_TRUE(errno == EAGAIN) << "ERROR: errno != EAGAIN, errno = " << errno << " EAGAIN = " << EAGAIN;
626
627 EXPECT_TRUE(mq_timedreceive(0, rMsg, getAttr.mq_msgsize, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
628 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
629
630 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
631 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
632
633 attr.mq_msgsize = MQ_MSG_SIZE;
634 attr.mq_maxmsg = MQ_MAX_MSG;
635 queue = mq_open(qName, O_CREAT | O_WRONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
636 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
637
638 EXPECT_TRUE(mq_timedreceive(0, rMsg, getAttr.mq_msgsize, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
639 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
640
641 attr.mq_flags |= O_NONBLOCK;
642 EXPECT_TRUE(mq_setattr(queue, &attr, NULL) == 0) << "ERROR: mq_setattr() != 0";
643 EXPECT_TRUE(mq_timedreceive(0, rMsg, getAttr.mq_msgsize, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
644 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
645
646 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
647 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
648 }
649
650 /* *
651 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0200
652 * @tc.name mq_timedreceive function errno for EINVAL test
653 * @tc.desc [C- SOFTWARE -0200]
654 */
HWTEST_F(IpcMqTest, testMqTimedReceiveEINVAL, Function | MediumTest | Level2)655 HWTEST_F(IpcMqTest, testMqTimedReceiveEINVAL, Function | MediumTest | Level2)
656 {
657 mqd_t queue;
658 int i;
659 unsigned int prio;
660 struct timespec ts = { 0, 0 };
661 struct mq_attr attr = { 0 };
662 struct mq_attr getAttr = { 0 };
663 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
664
665 sprintf(qName, "testMqTimedReceiveEINVAL_%d", GetRandom(10000));
666 attr.mq_msgsize = MQ_MSG_SIZE;
667 attr.mq_maxmsg = MQ_MAX_MSG;
668 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
669 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
670
671 for (i = 0; i < 3; i++) {
672 switch (i) {
673 case 0:
674 ts.tv_sec = -1;
675 ts.tv_nsec = 0;
676 break;
677 case 1:
678 ts.tv_sec = time(NULL) + 1;
679 ts.tv_nsec = -1;
680 break;
681 case 2:
682 ts.tv_sec = time(NULL) + 1;
683 ts.tv_nsec = 1000000000UL + 1UL;
684 break;
685 }
686
687 EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
688 EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &ts) == -1) <<
689 "ERROR: mq_timedreceive() != -1, i = " << i;
690 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL <<
691 " i = " << i;
692 }
693
694 EXPECT_TRUE(mq_timedreceive(queue, rMsg, 0, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
695 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL;
696
697 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
698 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
699 }
700
701 /* *
702 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0300
703 * @tc.name mq_timedreceive function errno for ETIMEDOUT test
704 * @tc.desc [C- SOFTWARE -0200]
705 */
HWTEST_F(IpcMqTest, testMqTimedReceiveETIMEDOUT, Function | MediumTest | Level3)706 HWTEST_F(IpcMqTest, testMqTimedReceiveETIMEDOUT, Function | MediumTest | Level3)
707 {
708 mqd_t queue;
709 unsigned int prio;
710 struct timespec ts = { 0, 0 };
711 struct mq_attr attr = { 0 };
712 struct mq_attr getAttr = { 0 };
713 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
714
715 sprintf(qName, "testMqTimedReceiveETIMEDOUT_%d", GetRandom(10000));
716 attr.mq_msgsize = MQ_MSG_SIZE;
717 attr.mq_maxmsg = MQ_MAX_MSG;
718 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
719 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
720
721 EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
722 ts.tv_sec = 0;
723 ts.tv_nsec = 100;
724 EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
725 EXPECT_TRUE(errno == ETIMEDOUT) << "ERROR: errno != ETIMEDOUT, errno = " << errno << " ETIMEDOUT = " << ETIMEDOUT;
726
727 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
728 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
729 }
730
731 /* *
732 * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0400
733 * @tc.name mq_timedreceive function errno for EMSGSIZE test
734 * @tc.desc [C- SOFTWARE -0200]
735 */
HWTEST_F(IpcMqTest, testMqTimedReceiveEMSGSIZE, Function | MediumTest | Level3)736 HWTEST_F(IpcMqTest, testMqTimedReceiveEMSGSIZE, Function | MediumTest | Level3)
737 {
738 mqd_t queue;
739 unsigned int prio;
740 struct timespec ts = { 0, 0 };
741 struct mq_attr attr = { 0 };
742 char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
743
744 sprintf(qName, "testMqTimedReceiveEMSGSIZE_%d", GetRandom(10000));
745 attr.mq_msgsize = MQ_MSG_SIZE;
746 attr.mq_maxmsg = MQ_MAX_MSG;
747 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
748 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
749
750 EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
751 ts.tv_sec = time(NULL) + 1;
752 ts.tv_nsec = 0;
753 EXPECT_TRUE(mq_timedreceive(queue, rMsg, 1, &prio, &ts) == -1) << "ERROR: mq_timedreceive() != -1";
754 EXPECT_TRUE(errno == EMSGSIZE) << "ERROR: errno != EMSGSIZE, errno = " << errno << " EMSGSIZE = " << EMSGSIZE;
755
756 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
757 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
758 }
759
760 /* *
761 * @tc.number SUB_KERNEL_IPC_MQ_UNLINK_0100
762 * @tc.name mq_unlink function errno for ENAMETOOLONG test
763 * @tc.desc [C- SOFTWARE -0200]
764 */
HWTEST_F(IpcMqTest, testMqUnlinkENAMETOOLONG, Function | MediumTest | Level2)765 HWTEST_F(IpcMqTest, testMqUnlinkENAMETOOLONG, Function | MediumTest | Level2)
766 {
767 char qName[MAX_MQ_NAME_LEN + 10];
768 int i;
769
770 for (i = 0; i < MAX_MQ_NAME_LEN + 5; i++) {
771 qName[i] = '8';
772 }
773 qName[i] = '\0';
774
775 ASSERT_TRUE(mq_unlink(qName) == -1) << "ERROR: mq_unlink() != -1";
776 ASSERT_TRUE(errno == ENAMETOOLONG) << "ERROR: errno != ENAMETOOLONG";
777 }
778
779 /* *
780 * @tc.number SUB_KERNEL_IPC_MQ_UNLINK_0200
781 * @tc.name mq_unlink function errno for ENOENT test
782 * @tc.desc [C- SOFTWARE -0200]
783 */
HWTEST_F(IpcMqTest, testMqUnlinkENOENT, Function | MediumTest | Level2)784 HWTEST_F(IpcMqTest, testMqUnlinkENOENT, Function | MediumTest | Level2)
785 {
786 char qName[MQ_NAME_LEN] = "/mq_file-does-not-exit";
787
788 ASSERT_TRUE(mq_unlink(qName) == -1) << "ERROR: mq_unlink() != -1";
789 ASSERT_TRUE(errno == ENOENT) << "ERROR: errno != ENOENT";
790 }
791
792 /* *
793 * @tc.number SUB_KERNEL_IPC_MQ_UNLINK_0300
794 * @tc.name mq_unlink function errno for EINVAL test
795 * @tc.desc [C- SOFTWARE -0200]
796 */
HWTEST_F(IpcMqTest, testMqUnlinkEINVAL, Function | MediumTest | Level3)797 HWTEST_F(IpcMqTest, testMqUnlinkEINVAL, Function | MediumTest | Level3)
798 {
799 ASSERT_TRUE(mq_unlink("") == -1) << "ERROR: mq_unlink() != -1";
800 ASSERT_TRUE(errno == EINVAL) << "ERROR: errno != ENOENT";
801 }
802
803 /* *
804 * @tc.number SUB_KERNEL_IPC_MQ_GETATTR_0100
805 * @tc.name mq_getattr function errno for EBAD and EINVALF test
806 * @tc.desc [C- SOFTWARE -0200]
807 */
HWTEST_F(IpcMqTest, testMqGetAttrEBADFEINVAL, Function | MediumTest | Level2)808 HWTEST_F(IpcMqTest, testMqGetAttrEBADFEINVAL, Function | MediumTest | Level2)
809 {
810 int ret;
811 mqd_t queue;
812 struct mq_attr mqstat = { 0 };
813 char qName[MQ_NAME_LEN];
814 int memRet = -1;
815
816 memRet = memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
817 EXPECT_EQ(0, memRet);
818
819 sprintf(qName, "testMqSendEINVAL_%d", GetRandom(10000));
820 queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, NULL);
821
822 ret = mq_getattr(0, &mqstat);
823 EXPECT_TRUE(ret == -1) << "ERROR: mq_getattr() != -1, ret = " << ret;
824 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
825
826 ret = mq_getattr(queue, nullptr);
827 EXPECT_TRUE(ret == -1) << "ERROR: mq_getattr() != -1, ret = " << ret;
828 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL , errno = " << errno << " EINVAL = " << EINVAL;
829
830 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
831 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
832 }
833
834 /* *
835 * @tc.number SUB_KERNEL_IPC_MQ_SETATTR_0100
836 * @tc.name mq_receive function errno for EBADF and EINVAL test
837 * @tc.desc [C- SOFTWARE -0200]
838 */
HWTEST_F(IpcMqTest, testMqSetAttrEBADFEINVAL, Function | MediumTest | Level2)839 HWTEST_F(IpcMqTest, testMqSetAttrEBADFEINVAL, Function | MediumTest | Level2)
840 {
841 char qName[MQ_NAME_LEN];
842 mqd_t queue;
843 struct mq_attr gMqstat = { 0 }, sMqstat = { 0 };
844 int memRet = -1;
845
846 sprintf(qName, "testMqSetAttrEBADFEINVAL_%d", GetRandom(10000));
847 queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
848 ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
849
850 memRet = memset_s(&gMqstat, sizeof(gMqstat), 0, sizeof(gMqstat));
851 EXPECT_EQ(0, memRet);
852 memRet = memset_s(&sMqstat, sizeof(sMqstat), 0, sizeof(sMqstat));
853 EXPECT_EQ(0, memRet);
854 EXPECT_TRUE(mq_getattr(queue, &gMqstat) == 0) << "ERROR: mq_getattr() != 0";
855
856 sMqstat.mq_flags |= O_NONBLOCK;
857 EXPECT_TRUE(mq_setattr(queue, &sMqstat, NULL) == 0) << "ERROR: mq_setattr() != 0";
858 EXPECT_TRUE(mq_getattr(queue, &gMqstat) == 0) << "ERROR: mq_getattr() != 0";
859 EXPECT_TRUE(gMqstat.mq_flags != sMqstat.mq_flags) << "ERROR: gMqstat != sMqstat, gMqstat.mq_flags = " <<
860 gMqstat.mq_flags << "sMqstat.mq_flags = " << sMqstat.mq_flags;
861
862 EXPECT_TRUE(mq_setattr(0, &sMqstat, NULL) == -1) << "ERROR: mq_setattr() != -1";
863 EXPECT_TRUE(errno == EBADF) << "ERROR: errno != EBADF, errno = " << errno << " EBADF = " << EBADF;
864
865 EXPECT_TRUE(mq_setattr(queue, NULL, NULL) == -1) << "ERROR: mq_setattr() != -1";
866 EXPECT_TRUE(errno == EINVAL) << "ERROR: errno != EINVAL, errno = " << errno << " EINVAL = " << EINVAL;
867
868 EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
869 ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
870 }
871