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 <mqueue.h>
18#include <fcntl.h>
19#include <sys/stat.h>
20#include <sys/types.h>
21#include <sys/wait.h>
22#include "log.h"
23#include "utils.h"
24#include "KernelConstants.h"
25#include <securec.h>
26
27using namespace testing::ext;
28
29/* *
30 * @tc.number SUB_KERNEL_IPC_MQ_0100
31 * @tc.name   mq_send and mq_receive function test
32 * @tc.desc   [C- SOFTWARE -0200]
33 */
34HWTEST_F(IpcMqTest, testMqOneLevelCom, Function | MediumTest | Level0)
35{
36    mqd_t queue;
37    unsigned int prio;
38    struct mq_attr getAttr = { 0 };
39    struct mq_attr setAttr = { 0 };
40    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
41
42    sprintf_s(qName, sizeof(qName), "testMqOneLevelCom_%d", GetRandom(10000));
43    setAttr.mq_msgsize = MQ_MSG_SIZE;
44    setAttr.mq_maxmsg = MQ_MAX_MSG;
45    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
46    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
47    EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
48
49    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
50    EXPECT_TRUE(getAttr.mq_msgsize == MQ_MSG_SIZE) << "getAttr.mq_msgsize != MQ_MSG_SIZE, "
51                                                   << "getAttr.mq_msgsize = " << getAttr.mq_msgsize;
52    EXPECT_TRUE(getAttr.mq_maxmsg == MQ_MAX_MSG) << "getAttr.mq_maxmsg != MQ_MAX_MSG, "
53                                                 << "getAttr.mq_maxmsg = " << getAttr.mq_maxmsg;
54
55    EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
56    EXPECT_TRUE(prio == 0) << "ERROR: prio != 0, prio = " << prio;
57    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
58        rMsg;
59    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
60    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
61}
62
63/* *
64 * @tc.number SUB_KERNEL_IPC_MQ_0200
65 * @tc.name   mq_timedsend and mq_timedreceive function test
66 * @tc.desc   [C- SOFTWARE -0200]
67 */
68HWTEST_F(IpcMqTest, testMqTimedOneLevelCom, Function | MediumTest | Level1)
69{
70    mqd_t queue;
71    unsigned int prio;
72    struct timespec tts = { 0 }, rts = { 0 };
73    struct mq_attr getAttr = { 0 };
74    struct mq_attr setAttr = { 0 };
75    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
76
77    sprintf_s(qName, sizeof(qName), "testMqTimedOneLevelCom_%d", GetRandom(10000));
78    setAttr.mq_msgsize = MQ_MSG_SIZE;
79    setAttr.mq_maxmsg = MQ_MAX_MSG;
80    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
81    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
82
83    tts.tv_sec = time(NULL) + 1;
84    tts.tv_nsec = 0;
85    EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
86
87    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
88    EXPECT_TRUE(getAttr.mq_msgsize == MQ_MSG_SIZE) << "getAttr.mq_msgsize != MQ_MSG_SIZE, "
89                                                   << "getAttr.mq_msgsize = " << getAttr.mq_msgsize;
90    EXPECT_TRUE(getAttr.mq_maxmsg == MQ_MAX_MSG) << "getAttr.mq_maxmsg != MQ_MAX_MSG, "
91                                                 << "getAttr.mq_maxmsg = " << getAttr.mq_maxmsg;
92    rts.tv_sec = time(NULL) + 1;
93    rts.tv_nsec = 0;
94    EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
95        "ERROR: mq_timedreceive() == -1";
96    EXPECT_TRUE(prio == 0) << "ERROR: prio != 0, prio = " << prio;
97    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
98        rMsg;
99    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
100    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
101}
102
103/* *
104 * @tc.number SUB_KERNEL_IPC_MQ_0300
105 * @tc.name   all send and all receive function test
106 * @tc.desc   [C- SOFTWARE -0200]
107 */
108HWTEST_F(IpcMqTest, testMqAllOneLevelCom, Function | MediumTest | Level2)
109{
110    mqd_t queue;
111    int memRet = -1;
112    unsigned int prio;
113    struct timespec tts { 0 }, rts = { 0 };
114    struct mq_attr getAttr = { 0 };
115    struct mq_attr setAttr = { 0 };
116    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
117
118    sprintf_s(qName, sizeof(qName), "testMqAllOneLevelCom_%d", GetRandom(10000));
119
120    memRet = memset_s(&getAttr, sizeof(getAttr), 0, sizeof(getAttr));
121    EXPECT_EQ(0, memRet);
122    memRet = memset_s(&setAttr, sizeof(setAttr), 0, sizeof(setAttr));
123    EXPECT_EQ(0, memRet);
124    setAttr.mq_msgsize = MQ_MSG_SIZE;
125    setAttr.mq_maxmsg = MQ_MAX_MSG;
126    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
127    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
128
129    EXPECT_TRUE(mq_getattr(queue, &setAttr) == 0) << "ERROR: mq_getattr() != 0";
130    setAttr.mq_msgsize = MQ_MSG_SIZE;
131    setAttr.mq_maxmsg = MQ_MAX_MSG;
132    EXPECT_TRUE(mq_setattr(queue, &setAttr, NULL) == 0) << "ERROR: mq_setattr() != 0";
133    EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
134
135    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
136    EXPECT_TRUE(getAttr.mq_msgsize == setAttr.mq_msgsize) << "ERROR: getAttr.mq_msgsize != setAttr.mq_msgsize,"
137        " getAttr.mq_msgsize = " <<
138        getAttr.mq_msgsize << " setAttr.mq_msgsize = " << setAttr.mq_msgsize;
139    EXPECT_TRUE(getAttr.mq_maxmsg == setAttr.mq_maxmsg) << "ERROR: getAttr.mq_maxmsg != setAttr.mq_maxmsg,"
140        " getAttr.mq_maxmsg = " <<
141        getAttr.mq_maxmsg << " setAttr.mq_maxmsg = " << setAttr.mq_maxmsg;
142    EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1, getAttr.mq_curmsgs = " <<
143        getAttr.mq_curmsgs;
144
145    EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
146    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
147        rMsg;
148
149    tts.tv_sec = time(NULL) + 1;
150    tts.tv_nsec = 0;
151    EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
152
153    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
154    EXPECT_TRUE(getAttr.mq_msgsize == setAttr.mq_msgsize) << "ERROR: getAttr.mq_msgsize != setAttr.mq_msgsize";
155    EXPECT_TRUE(getAttr.mq_maxmsg == setAttr.mq_maxmsg) << "ERROR: getAttr.mq_maxmsg != setAttr.mq_maxmsg";
156    EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1";
157
158    rts.tv_sec = time(NULL) + 1;
159    rts.tv_nsec = 0;
160    EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
161        "ERROR: mq_timedreceive() == -1";
162    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
163        rMsg;
164
165    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
166    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0"
167                                       << " errno = " << errno << " strerror(errno) = " << strerror(errno);
168}
169
170/* *
171 * @tc.number SUB_KERNEL_IPC_MQ_0400
172 * @tc.name   mq_send and mq_receive function test in child and parent process
173 * @tc.desc   [C- SOFTWARE -0200]
174 */
175HWTEST_F(IpcMqTest, testMqTwoLevelCom, Function | MediumTest | Level1)
176{
177    mqd_t queue;
178    pid_t pid;
179    unsigned int prio;
180    struct mq_attr getAttr = { 0 };
181    struct mq_attr setAttr = { 0 };
182    char qName[MQ_NAME_LEN], rMsg[MAX_MQ_MSG_SIZE], sMsg[MAX_MQ_MSG_SIZE];
183
184    for (int i = 0; i < MAX_MQ_MSG_SIZE; i++) {
185        sMsg[i] = 0x36;
186        rMsg[i] = 0x00;
187    }
188
189    sprintf_s(qName, sizeof(qName), "testMqMaxLenTwoLevelCom_%d", GetRandom(10000));
190    setAttr.mq_msgsize = MAX_MQ_MSG_SIZE;
191    setAttr.mq_maxmsg = MQ_MAX_MSG;
192    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
193    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
194
195    pid = fork();
196    if (pid < 0) {
197        goto FINISH;
198    } else if (pid == 0) {
199        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
200        EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
201        EXPECT_TRUE(prio == 0) << "ERROR: prio != 0, prio = " << prio;
202        EXPECT_TRUE(strncmp(sMsg, rMsg, MAX_MQ_MSG_SIZE) == 0) << "sent != received: sent = " << sMsg <<
203            ", received = " << rMsg;
204        EXPECT_TRUE(mq_send(queue, sMsg, MAX_MQ_MSG_SIZE, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
205        exit(0);
206    } else {
207        int status;
208        EXPECT_TRUE(mq_send(queue, sMsg, MAX_MQ_MSG_SIZE, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
209
210        pid = waitpid(pid, &status, 0);
211        EXPECT_TRUE(pid != 0) << "ERROR: pid == 0";
212        EXPECT_TRUE(WIFEXITED(status) != 0) << "ERROR: WIFEXITED(status) == 0";
213        EXPECT_TRUE(WEXITSTATUS(status) == 0) << "ERROR: WEXITSTATUS(status) != 0"
214                                              << ", WEXITSTATUS(status) = " << WEXITSTATUS(status);
215        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
216        EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
217                                             << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
218        EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
219        EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
220        EXPECT_TRUE(strncmp(sMsg, rMsg, MAX_MQ_MSG_SIZE) == 0) << "sent != received: sent = " << sMsg <<
221            ", received = " << rMsg;
222    }
223
224FINISH:
225    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
226    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
227}
228
229/* *
230 * @tc.number SUB_KERNEL_IPC_MQ_0500
231 * @tc.name   mq_timedsend and mq_timedreceive function test in child and parent process
232 * @tc.desc   [C- SOFTWARE -0200]
233 */
234HWTEST_F(IpcMqTest, testMqTimedTwoLevelCom, Function | MediumTest | Level1)
235{
236    mqd_t queue;
237    pid_t pid;
238    unsigned int prio;
239    struct timespec tts { 0 }, rts = { 0 };
240    struct mq_attr getAttr = { 0 };
241    struct mq_attr setAttr = { 0 };
242    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
243
244    sprintf_s(qName, sizeof(qName), "testMqTimedTwoLevelCom_%d", GetRandom(10000));
245    setAttr.mq_msgsize = MQ_MSG_SIZE;
246    setAttr.mq_maxmsg = MQ_MAX_MSG;
247    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
248    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
249
250    pid = fork();
251    if (pid < 0) {
252        goto FINISH;
253    } else if (pid == 0) {
254        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
255        rts.tv_sec = time(NULL) + 3;
256        rts.tv_nsec = 0;
257        EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
258            "ERROR: mq_timedreceive() == -1";
259        EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != 0, prio = " << prio;
260        EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
261            ", received = " << rMsg;
262
263        tts.tv_sec = time(NULL) + 3;
264        tts.tv_nsec = 0;
265        EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
266        exit(0);
267    } else {
268        int status;
269        tts.tv_sec = time(NULL) + 3;
270        tts.tv_nsec = 0;
271        EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
272
273        pid = waitpid(pid, &status, 0);
274        EXPECT_TRUE(pid != 0) << "ERROR: pid == 0";
275        EXPECT_TRUE(WIFEXITED(status) != 0) << "ERROR: WIFEXITED(status) == 0";
276        EXPECT_TRUE(WEXITSTATUS(status) == 0) << "ERROR: WEXITSTATUS(status) != 0"
277                                              << ", WEXITSTATUS(status) = " << WEXITSTATUS(status);
278        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
279        EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
280                                             << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
281        rts.tv_sec = time(NULL) + 3;
282        rts.tv_nsec = 0;
283        EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
284            "ERROR: mq_timedreceive() == -1";
285        EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != 0, prio = " << prio;
286        EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
287            ", received = " << rMsg;
288    }
289
290FINISH:
291    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
292    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
293}
294
295/* *
296 * @tc.number SUB_KERNEL_IPC_MQ_0600
297 * @tc.name   all send and all receive function test in child and parent process
298 * @tc.desc   [C- SOFTWARE -0200]
299 */
300HWTEST_F(IpcMqTest, testMqAllTwoLevelCom, Function | MediumTest | Level1)
301{
302    mqd_t queue;
303    pid_t pid;
304    unsigned int prio;
305    struct timespec tts { 0 }, rts = { 0 };
306    struct mq_attr getAttr = { 0 };
307    struct mq_attr setAttr = { 0 };
308    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
309
310    sprintf_s(qName, sizeof(qName), "testMqAllTwoLevelCom_%d", GetRandom(10000));
311    setAttr.mq_msgsize = MQ_MSG_SIZE;
312    setAttr.mq_maxmsg = MQ_MAX_MSG;
313    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
314    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
315
316    pid = fork();
317    if (pid < 0) {
318        goto FINISH;
319    } else if (pid == 0) {
320        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
321        rts.tv_sec = time(NULL) + 1;
322        rts.tv_nsec = 0;
323        EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
324            "ERROR: mq_timedreceive() == -1";
325        EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
326        EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
327            ", received = " << rMsg;
328
329        tts.tv_sec = time(NULL) + 1;
330        tts.tv_nsec = 0;
331        EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
332        exit(0);
333    } else {
334        int status;
335        EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
336
337        pid = waitpid(pid, &status, 0);
338        EXPECT_TRUE(pid != 0) << "ERROR: pid == 0";
339        EXPECT_TRUE(WIFEXITED(status) != 0) << "ERROR: WIFEXITED(status) == 0";
340        EXPECT_TRUE(WEXITSTATUS(status) == 0) << "ERROR: WEXITSTATUS(status) != 0"
341                                              << ", WEXITSTATUS(status) = " << WEXITSTATUS(status);
342        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
343        EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
344                                             << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
345        EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
346        EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
347        EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
348            ", received = " << rMsg;
349    }
350
351FINISH:
352    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
353    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
354}
355
356static void *PthreadCom(void *arg)
357{
358    mqd_t queue;
359    unsigned int prio;
360    struct mq_attr getAttr = { 0 };
361    char rMsg[MQ_RX_LEN];
362
363    queue = (mqd_t)arg;
364    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
365    EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
366    EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != 0, prio = " << prio;
367    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
368        rMsg;
369    EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
370
371    return nullptr;
372}
373
374/* *
375 * @tc.number SUB_KERNEL_IPC_MQ_0700
376 * @tc.name   mq_send and mq_receive function test in thread and process
377 * @tc.desc   [C- SOFTWARE -0200]
378 */
379HWTEST_F(IpcMqTest, testMqTwoThreadCom, Function | MediumTest | Level1)
380{
381    mqd_t queue;
382    pthread_t tid;
383    unsigned int prio;
384    struct mq_attr getAttr = { 0 };
385    struct mq_attr setAttr = { 0 };
386    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
387
388    sprintf_s(qName, sizeof(qName), "testMqTwoLevelCom_%d", GetRandom(10000));
389    setAttr.mq_msgsize = MQ_MSG_SIZE;
390    setAttr.mq_maxmsg = MQ_MAX_MSG;
391    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
392    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
393
394    EXPECT_TRUE(pthread_create(&tid, NULL, PthreadCom, (void *)queue) != -1) << "ERROR: pthread_create() == -1";
395
396    EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
397    EXPECT_TRUE(pthread_join(tid, NULL) == 0) << "ERROR: pthread_join() != 0";
398
399    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
400    EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
401                                         << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
402    EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
403    EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != 0, prio = " << prio;
404    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
405        rMsg;
406
407    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
408    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
409}
410
411static void *PthreadTimedCom(void *arg)
412{
413    mqd_t queue;
414    unsigned int prio;
415    struct timespec tts { 0 }, rts = { 0 };
416    struct mq_attr getAttr = { 0 };
417    char rMsg[MQ_RX_LEN];
418
419    queue = (mqd_t)arg;
420    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
421    rts.tv_sec = time(NULL) + 1;
422    rts.tv_nsec = 0;
423    EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
424        "ERROR: mq_timedreceive() == -1";
425    EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
426    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
427        rMsg;
428
429    tts.tv_sec = time(NULL) + 1;
430    tts.tv_nsec = 0;
431    EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
432
433    return nullptr;
434}
435
436/* *
437 * @tc.number SUB_KERNEL_IPC_MQ_0800
438 * @tc.name   mq_timedsend and mq_timedreceive function test in thread and process
439 * @tc.desc   [C- SOFTWARE -0200]
440 */
441HWTEST_F(IpcMqTest, testMqTimedTwoThreadCom, Function | MediumTest | Level1)
442{
443    mqd_t queue;
444    pthread_t tid;
445    unsigned int prio;
446    struct timespec tts { 0 }, rts = { 0 };
447    struct mq_attr getAttr = { 0 };
448    struct mq_attr setAttr = { 0 };
449    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
450
451    sprintf_s(qName, sizeof(qName), "testMqTimedTwoThreadCom_%d", GetRandom(10000));
452    setAttr.mq_msgsize = MQ_MSG_SIZE;
453    setAttr.mq_maxmsg = MQ_MAX_MSG;
454    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
455    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
456
457    EXPECT_TRUE(pthread_create(&tid, NULL, PthreadTimedCom, (void *)queue) != -1) << "ERROR: pthread_create() == -1";
458
459    tts.tv_sec = time(NULL) + 1;
460    tts.tv_nsec = 0;
461    EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
462    EXPECT_TRUE(pthread_join(tid, NULL) == 0) << "ERROR: pthread_join() != 0";
463
464    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
465    EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
466                                         << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
467    rts.tv_sec = time(NULL) + 1;
468    rts.tv_nsec = 0;
469    EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
470        "ERROR: mq_timedreceive() == -1";
471    EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
472    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
473        rMsg;
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
479static void *PthreadAllCom(void *arg)
480{
481    mqd_t queue;
482    unsigned int prio;
483    struct timespec tts { 0 }, rts = { 0 };
484    struct mq_attr getAttr = { 0 };
485    char rMsg[MQ_RX_LEN];
486
487    queue = (mqd_t)arg;
488    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
489    rts.tv_sec = time(NULL) + 1;
490    rts.tv_nsec = 0;
491    EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
492        "ERROR: mq_timedreceive() == -1";
493    EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
494    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
495        rMsg;
496    tts.tv_sec = time(NULL) + 1;
497    tts.tv_nsec = 0;
498    EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) << "ERROR: mq_timedsend() != 0";
499
500    return nullptr;
501}
502
503/* *
504 * @tc.number SUB_KERNEL_IPC_MQ_0900
505 * @tc.name   all send and all receive function test in thread and process
506 * @tc.desc   [C- SOFTWARE -0200]
507 */
508HWTEST_F(IpcMqTest, testMqAllTwoThreadCom, Function | MediumTest | Level1)
509{
510    mqd_t queue;
511    pthread_t tid;
512    unsigned int prio;
513    struct mq_attr getAttr = { 0 };
514    struct mq_attr setAttr = { 0 };
515    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
516
517    sprintf_s(qName, sizeof(qName), "testMqAllTwoThreadCom_%d", GetRandom(10000));
518    setAttr.mq_msgsize = MQ_MSG_SIZE;
519    setAttr.mq_maxmsg = MQ_MAX_MSG;
520    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
521    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
522
523    EXPECT_TRUE(pthread_create(&tid, NULL, PthreadAllCom, (void *)queue) != -1) << "ERROR: pthread_create() == -1";
524
525    EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
526    EXPECT_TRUE(pthread_join(tid, NULL) == 0) << "ERROR: pthread_join() != 0";
527
528    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
529    EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
530                                         << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
531    EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
532    EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
533    EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG << ", received = " <<
534        rMsg;
535
536    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
537    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
538}
539
540/* *
541 * @tc.number SUB_KERNEL_IPC_MQ_1000
542 * @tc.name   all send and all receive function test in more process
543 * @tc.desc   [C- SOFTWARE -0200]
544 */
545HWTEST_F(IpcMqTest, testMqThreeLevelCom, Function | MediumTest | Level2)
546{
547    mqd_t queue;
548    pid_t pid;
549    unsigned int prio;
550    struct timespec tts { 0 }, rts = { 0 };
551    struct mq_attr getAttr = { 0 };
552    struct mq_attr setAttr = { 0 };
553    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
554
555    sprintf_s(qName, sizeof(qName), "testMqThreeLevelCom_%d", GetRandom(10000));
556    setAttr.mq_msgsize = MQ_MSG_SIZE;
557    setAttr.mq_maxmsg = MQ_MAX_MSG;
558    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
559    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
560
561    pid = fork();
562    if (pid < 0) {
563        goto FINISH;
564    } else if (pid == 0) {
565        pid = fork();
566        if (pid == 0) {
567            EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
568            EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1"
569                                                                                  << " errno = " << errno <<
570                " strerror(errno) = " << strerror(errno);
571            EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
572            EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
573                ", received = " << rMsg;
574            EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
575        } else {
576            int status;
577
578            pid = waitpid(pid, &status, 0);
579            EXPECT_TRUE(pid != 0) << "ERROR: pid == 0";
580            EXPECT_TRUE(WIFEXITED(status) != 0) << "ERROR: WIFEXITED(status) == 0";
581            EXPECT_TRUE(WEXITSTATUS(status) == 0) << "ERROR: WEXITSTATUS(status) != 0"
582                                                  << ", WEXITSTATUS(status) = " << WEXITSTATUS(status);
583
584            EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
585            rts.tv_sec = time(NULL) + 1;
586            rts.tv_nsec = 0;
587            EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
588                "ERROR: mq_timedreceive() == -1";
589            EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
590            EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
591                ", received = " << rMsg;
592
593            tts.tv_sec = time(NULL) + 1;
594            tts.tv_nsec = 0;
595            EXPECT_TRUE(mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts) == 0) <<
596                "ERROR: mq_timedsend() != 0";
597        }
598        exit(0);
599    } else {
600        int status;
601        EXPECT_TRUE(mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
602
603        pid = waitpid(pid, &status, 0);
604        EXPECT_TRUE(pid != 0) << "ERROR: pid == 0";
605        EXPECT_TRUE(WIFEXITED(status) != 0) << "ERROR: WIFEXITED(status) == 0";
606        EXPECT_TRUE(WEXITSTATUS(status) == 0) << "ERROR: WEXITSTATUS(status) != 0"
607                                              << ", WEXITSTATUS(status) = " << WEXITSTATUS(status);
608
609        EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
610        EXPECT_TRUE(getAttr.mq_curmsgs == 1) << "ERROR: getAttr.mq_curmsgs != 1"
611                                             << ", getAttr.mq_curmsgs = " << getAttr.mq_curmsgs;
612        rts.tv_sec = time(NULL) + 1;
613        rts.tv_nsec = 0;
614        EXPECT_TRUE(mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts) != -1) <<
615            "ERROR: mq_timedreceive() == -1";
616        EXPECT_TRUE(prio == MQ_MSG_PRIO) << "ERROR: prio != MQ_MSG_PRIO, prio = " << prio;
617        EXPECT_TRUE(strncmp(MQ_MSG, rMsg, MQ_MSG_LEN) == 0) << "sent != received: sent = " << MQ_MSG <<
618            ", received = " << rMsg;
619    }
620
621FINISH:
622    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
623    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
624}
625
626/* *
627 * @tc.number SUB_KERNEL_IPC_MQ_1100
628 * @tc.name   mq_send and mq_receive max packet function test
629 * @tc.desc   [C- SOFTWARE -0200]
630 */
631HWTEST_F(IpcMqTest, testMqMinMaxLen, Function | MediumTest | Level2)
632{
633    mqd_t queue;
634    unsigned int prio;
635    struct mq_attr getAttr = { 0 };
636    struct mq_attr setAttr = { 0 };
637    char qName[MQ_NAME_LEN], rMsg[MAX_MQ_MSG_SIZE], sMsg[MAX_MQ_MSG_SIZE];
638
639    for (int i = 0; i < MAX_MQ_MSG_SIZE; i++) {
640        sMsg[i] = 0x36;
641        rMsg[i] = 0x00;
642    }
643
644    sprintf_s(qName, sizeof(qName), "testMqMaxLen_%d", GetRandom(10000));
645    setAttr.mq_msgsize = MAX_MQ_MSG_SIZE;
646    setAttr.mq_maxmsg = MQ_MAX_MSG;
647    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
648    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1"
649                                    << " errno = " << errno << " strerror(errno) = " << strerror(errno);
650    EXPECT_TRUE(mq_send(queue, sMsg, MAX_MQ_MSG_SIZE, MQ_MSG_PRIO) == 0) << "ERROR: mq_send() != 0";
651    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
652    EXPECT_TRUE(mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio) != -1) << "ERROR: mq_receive() == -1";
653    EXPECT_TRUE(strncmp(sMsg, rMsg, MAX_MQ_MSG_SIZE) == 0) << "sent != received: sent = " << sMsg << ", received = " <<
654        rMsg;
655    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
656    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0";
657}
658
659/* *
660 * @tc.number SUB_KERNEL_IPC_MQ_1200
661 * @tc.name   mq_setattr set and clean mq_flags for O_NONBLOCK function test
662 * @tc.desc   [C- SOFTWARE -0200]
663 */
664HWTEST_F(IpcMqTest, testMqSetGetAttr, Function | MediumTest | Level1)
665{
666    mqd_t queue;
667    struct mq_attr getAttr = { 0 };
668    struct mq_attr setAttr = { 0 };
669    char qName[MQ_NAME_LEN];
670    int memRet = -1;
671
672    sprintf_s(qName, sizeof(qName), "testMqFunction_%d", GetRandom(10000));
673
674    memRet = memset_s(&setAttr, sizeof(setAttr), 0, sizeof(setAttr));
675    EXPECT_EQ(0, memRet);
676    setAttr.mq_msgsize = MQ_MSG_SIZE;
677    setAttr.mq_maxmsg = MQ_MAX_MSG;
678    setAttr.mq_flags = O_NONBLOCK;
679    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
680    ASSERT_TRUE(queue != (mqd_t)-1) << "ERROR: mq_open() == (mqd_t)-1";
681
682    memRet = memset_s(&getAttr, sizeof(getAttr), 0, sizeof(getAttr));
683    EXPECT_EQ(0, memRet);
684    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
685    EXPECT_TRUE((getAttr.mq_flags & O_NONBLOCK) == O_NONBLOCK);
686
687    setAttr.mq_flags &= ~O_NONBLOCK;
688    EXPECT_TRUE(mq_setattr(queue, &setAttr, NULL) == 0) << "ERROR: mq_setattr() != 0";
689
690    EXPECT_TRUE(mq_getattr(queue, &getAttr) == 0) << "ERROR: mq_getattr() != 0";
691    LOG("setAttr.mq_flags = 0x%08x, getAttr.mq_flags = 0x%08x ", setAttr.mq_flags, getAttr.mq_flags);
692    EXPECT_TRUE((getAttr.mq_flags & O_NONBLOCK) == 0) << "ERROR: getAttr.mq_flags & O_NONBLOCK != 0,"
693        " getAttr.mq_flags = " <<
694        getAttr.mq_flags << " setAttr.mq_flags = " << setAttr.mq_flags;
695    EXPECT_TRUE(mq_close(queue) == 0) << "ERROR: mq_close() != 0";
696    ASSERT_TRUE(mq_unlink(qName) == 0) << "ERROR: mq_unlink() != 0"
697                                       << " errno = " << errno << " strerror(errno) = " << strerror(errno);
698}
699