1 | /* $Id: tstRTPipe.cpp 56290 2015-06-09 14:01:31Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT Testcase - RTPipe.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2010-2015 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | *
|
---|
17 | * The contents of this file may alternatively be used under the terms
|
---|
18 | * of the Common Development and Distribution License Version 1.0
|
---|
19 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
20 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
21 | * CDDL are applicable instead of those of the GPL.
|
---|
22 | *
|
---|
23 | * You may elect to license modified versions of this file under the
|
---|
24 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
25 | */
|
---|
26 |
|
---|
27 |
|
---|
28 | /*******************************************************************************
|
---|
29 | * Header Files *
|
---|
30 | *******************************************************************************/
|
---|
31 | #include <iprt/pipe.h>
|
---|
32 |
|
---|
33 | #include <iprt/env.h>
|
---|
34 | #include <iprt/err.h>
|
---|
35 | #include <iprt/initterm.h>
|
---|
36 | #include <iprt/mem.h>
|
---|
37 | #include <iprt/message.h>
|
---|
38 | #include <iprt/param.h>
|
---|
39 | #include <iprt/process.h>
|
---|
40 | #include <iprt/string.h>
|
---|
41 | #include <iprt/test.h>
|
---|
42 |
|
---|
43 |
|
---|
44 | /*******************************************************************************
|
---|
45 | * Global Variables *
|
---|
46 | *******************************************************************************/
|
---|
47 | static const char g_szTest4Message[] = "This is test #4, everything is working fine.\n\r";
|
---|
48 | static const char g_szTest5Message[] = "This is test #5, everything is working fine.\n\r";
|
---|
49 |
|
---|
50 |
|
---|
51 | static RTEXITCODE tstRTPipe5Child(const char *pszPipe)
|
---|
52 | {
|
---|
53 | int rc = RTR3InitExeNoArguments(0);
|
---|
54 | if (RT_FAILURE(rc))
|
---|
55 | return RTMsgInitFailure(rc);
|
---|
56 |
|
---|
57 | int64_t iNative;
|
---|
58 | rc = RTStrToInt64Full(pszPipe, 10, &iNative);
|
---|
59 | if (RT_FAILURE(rc))
|
---|
60 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrToUInt64Full(%s) -> %Rrc\n", pszPipe, rc);
|
---|
61 |
|
---|
62 | RTPIPE hPipe;
|
---|
63 | rc = RTPipeFromNative(&hPipe, (RTHCINTPTR)iNative, RTPIPE_N_READ);
|
---|
64 | if (RT_FAILURE(rc))
|
---|
65 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeFromNative(,%s,READ) -> %Rrc\n", pszPipe, rc);
|
---|
66 |
|
---|
67 | ///
|
---|
68 | char szTmp[1024];
|
---|
69 | size_t cbRead = 0;
|
---|
70 | rc = RTPipeReadBlocking(hPipe, szTmp, sizeof(szTmp) - 1, &cbRead);
|
---|
71 | if (RT_FAILURE(rc))
|
---|
72 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeReadBlocking() -> %Rrc\n", rc);
|
---|
73 | szTmp[cbRead] = '\0';
|
---|
74 |
|
---|
75 | size_t cbRead2;
|
---|
76 | char szTmp2[4];
|
---|
77 | rc = RTPipeReadBlocking(hPipe, szTmp2, sizeof(szTmp2), &cbRead2);
|
---|
78 | if (rc != VERR_BROKEN_PIPE)
|
---|
79 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeReadBlocking() -> %Rrc instead of VERR_BROKEN_PIPE\n", rc);
|
---|
80 |
|
---|
81 | rc = RTPipeClose(hPipe);
|
---|
82 | if (RT_FAILURE(rc))
|
---|
83 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeClose() -> %Rrc\n", rc);
|
---|
84 |
|
---|
85 | if (memcmp(szTmp, g_szTest5Message, sizeof(g_szTest5Message)))
|
---|
86 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Message mismatch.\n:Expected '%s'\nGot '%s'\n", g_szTest5Message, szTmp);
|
---|
87 |
|
---|
88 | return RTEXITCODE_SUCCESS;
|
---|
89 | }
|
---|
90 |
|
---|
91 | static void tstRTPipe5(void)
|
---|
92 | {
|
---|
93 | RTTestISub("Inherit non-standard pipe handle, read end");
|
---|
94 |
|
---|
95 | char szPathSelf[RTPATH_MAX];
|
---|
96 | RTTESTI_CHECK_RETV(RTProcGetExecutablePath(szPathSelf, sizeof(szPathSelf)) == szPathSelf);
|
---|
97 |
|
---|
98 | RTPIPE hPipeR;
|
---|
99 | RTPIPE hPipeW;
|
---|
100 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ), VINF_SUCCESS);
|
---|
101 |
|
---|
102 | RTHCINTPTR hNative = RTPipeToNative(hPipeR);
|
---|
103 | RTTESTI_CHECK_RETV(hNative != -1);
|
---|
104 |
|
---|
105 | char szNative[64];
|
---|
106 | RTStrPrintf(szNative, sizeof(szNative), "%RHi", hNative);
|
---|
107 | const char *papszArgs[4] = { szPathSelf, "--child-5", szNative, NULL };
|
---|
108 |
|
---|
109 | RTPROCESS hChild;
|
---|
110 | RTTESTI_CHECK_RC_RETV(RTProcCreate(szPathSelf, papszArgs, RTENV_DEFAULT, 0 /*fFlags*/, &hChild), VINF_SUCCESS);
|
---|
111 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
112 |
|
---|
113 | RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW, g_szTest5Message, sizeof(g_szTest5Message) - 1, NULL), VINF_SUCCESS);
|
---|
114 | int rc;
|
---|
115 | RTTESTI_CHECK_RC(rc = RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
116 | if (RT_FAILURE(rc))
|
---|
117 | RTTESTI_CHECK_RC(RTProcTerminate(hChild), VINF_SUCCESS);
|
---|
118 |
|
---|
119 | RTPROCSTATUS ProcStatus;
|
---|
120 | RTTESTI_CHECK_RC(rc = RTProcWait(hChild, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus), VINF_SUCCESS);
|
---|
121 | if (RT_FAILURE(rc))
|
---|
122 | return;
|
---|
123 | RTTESTI_CHECK( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
|
---|
124 | && ProcStatus.iStatus == 0);
|
---|
125 | }
|
---|
126 |
|
---|
127 |
|
---|
128 | static RTEXITCODE tstRTPipe4Child(const char *pszPipe)
|
---|
129 | {
|
---|
130 | int rc = RTR3InitExeNoArguments(0);
|
---|
131 | if (RT_FAILURE(rc))
|
---|
132 | return RTMsgInitFailure(rc);
|
---|
133 |
|
---|
134 | int64_t iNative;
|
---|
135 | rc = RTStrToInt64Full(pszPipe, 10, &iNative);
|
---|
136 | if (RT_FAILURE(rc))
|
---|
137 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrToUInt64Full(%s) -> %Rrc\n", pszPipe, rc);
|
---|
138 |
|
---|
139 | RTPIPE hPipe;
|
---|
140 | rc = RTPipeFromNative(&hPipe, (RTHCINTPTR)iNative, RTPIPE_N_WRITE);
|
---|
141 | if (RT_FAILURE(rc))
|
---|
142 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeFromNative(,%s,WRITE) -> %Rrc\n", pszPipe, rc);
|
---|
143 |
|
---|
144 | rc = RTPipeWriteBlocking(hPipe, g_szTest4Message, sizeof(g_szTest4Message) - 1, NULL);
|
---|
145 | if (RT_FAILURE(rc))
|
---|
146 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeWriteBlocking() -> %Rrc\n", rc);
|
---|
147 |
|
---|
148 | rc = RTPipeClose(hPipe);
|
---|
149 | if (RT_FAILURE(rc))
|
---|
150 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPipeClose() -> %Rrc\n", rc);
|
---|
151 | return RTEXITCODE_SUCCESS;
|
---|
152 | }
|
---|
153 |
|
---|
154 | static void tstRTPipe4(void)
|
---|
155 | {
|
---|
156 | RTTestISub("Inherit non-standard pipe handle, write end");
|
---|
157 |
|
---|
158 | char szPathSelf[RTPATH_MAX];
|
---|
159 | RTTESTI_CHECK_RETV(RTProcGetExecutablePath(szPathSelf, sizeof(szPathSelf)) == szPathSelf);
|
---|
160 |
|
---|
161 | RTPIPE hPipeR;
|
---|
162 | RTPIPE hPipeW;
|
---|
163 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
|
---|
164 |
|
---|
165 | RTHCINTPTR hNative = RTPipeToNative(hPipeW);
|
---|
166 | RTTESTI_CHECK_RETV(hNative != -1);
|
---|
167 |
|
---|
168 | char szNative[64];
|
---|
169 | RTStrPrintf(szNative, sizeof(szNative), "%RHi", hNative);
|
---|
170 | const char *papszArgs[4] = { szPathSelf, "--child-4", szNative, NULL };
|
---|
171 |
|
---|
172 | RTPROCESS hChild;
|
---|
173 | RTTESTI_CHECK_RC_RETV(RTProcCreate(szPathSelf, papszArgs, RTENV_DEFAULT, 0 /*fFlags*/, &hChild), VINF_SUCCESS);
|
---|
174 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
175 |
|
---|
176 | char szTmp[1024];
|
---|
177 | size_t cbRead = 0;
|
---|
178 | int rc;
|
---|
179 | RTTESTI_CHECK_RC(rc = RTPipeReadBlocking(hPipeR, szTmp, sizeof(szTmp) - 1, &cbRead), VINF_SUCCESS);
|
---|
180 | if (RT_FAILURE(rc))
|
---|
181 | cbRead = 0;
|
---|
182 | RTTESTI_CHECK_RETV(cbRead < sizeof(szTmp));
|
---|
183 | szTmp[cbRead] = '\0';
|
---|
184 |
|
---|
185 | size_t cbRead2;
|
---|
186 | char szTmp2[4];
|
---|
187 | RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeR, szTmp2, sizeof(szTmp2), &cbRead2), VERR_BROKEN_PIPE);
|
---|
188 | RTTESTI_CHECK_RC(rc = RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
189 | if (RT_FAILURE(rc))
|
---|
190 | RTTESTI_CHECK_RC(RTProcTerminate(hChild), VINF_SUCCESS);
|
---|
191 |
|
---|
192 | RTPROCSTATUS ProcStatus;
|
---|
193 | RTTESTI_CHECK_RC(rc = RTProcWait(hChild, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus), VINF_SUCCESS);
|
---|
194 | if (RT_FAILURE(rc))
|
---|
195 | return;
|
---|
196 | RTTESTI_CHECK( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
|
---|
197 | && ProcStatus.iStatus == 0);
|
---|
198 | if (memcmp(szTmp, g_szTest4Message, sizeof(g_szTest4Message)))
|
---|
199 | RTTestIFailed("Message mismatch.\n:Expected '%s'\nGot '%s'\n", g_szTest4Message, szTmp);
|
---|
200 | }
|
---|
201 |
|
---|
202 |
|
---|
203 | static void tstRTPipe3(void)
|
---|
204 | {
|
---|
205 | RTTestISub("Full write buffer");
|
---|
206 |
|
---|
207 | RTPIPE hPipeR = (RTPIPE)999999;
|
---|
208 | RTPIPE hPipeW = (RTPIPE)999999;
|
---|
209 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
210 |
|
---|
211 | static char s_abBuf[_256K];
|
---|
212 | int rc = VINF_SUCCESS;
|
---|
213 | size_t cbTotal = 0;
|
---|
214 | memset(s_abBuf, 0xff, sizeof(s_abBuf));
|
---|
215 | for (;;)
|
---|
216 | {
|
---|
217 | RTTESTI_CHECK(cbTotal < _1G);
|
---|
218 | if (cbTotal > _1G)
|
---|
219 | break;
|
---|
220 |
|
---|
221 | size_t cbWritten = _1G;
|
---|
222 | rc = RTPipeWrite(hPipeW, s_abBuf, sizeof(s_abBuf), &cbWritten);
|
---|
223 | RTTESTI_CHECK_MSG(rc == VINF_SUCCESS || rc == VINF_TRY_AGAIN, ("rc=%Rrc\n", rc));
|
---|
224 | if (rc != VINF_SUCCESS)
|
---|
225 | break;
|
---|
226 | cbTotal += cbWritten;
|
---|
227 | }
|
---|
228 |
|
---|
229 | if (rc == VINF_TRY_AGAIN)
|
---|
230 | {
|
---|
231 | RTTestIPrintf(RTTESTLVL_ALWAYS, "cbTotal=%zu (%#zx)\n", cbTotal, cbTotal);
|
---|
232 | RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 0), VERR_TIMEOUT);
|
---|
233 | RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 1), VERR_TIMEOUT);
|
---|
234 | size_t cbRead;
|
---|
235 | RTTESTI_CHECK_RC(RTPipeRead(hPipeR, s_abBuf, RT_MIN(sizeof(s_abBuf), cbTotal) / 2, &cbRead), VINF_SUCCESS);
|
---|
236 | RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 0), VINF_SUCCESS);
|
---|
237 | RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 1), VINF_SUCCESS);
|
---|
238 |
|
---|
239 | size_t cbWritten = _1G;
|
---|
240 | rc = RTPipeWrite(hPipeW, s_abBuf, sizeof(s_abBuf), &cbWritten);
|
---|
241 | RTTESTI_CHECK(rc == VINF_SUCCESS);
|
---|
242 | }
|
---|
243 |
|
---|
244 | RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
245 | RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
246 | }
|
---|
247 |
|
---|
248 | static void tstRTPipe2(void)
|
---|
249 | {
|
---|
250 | RTTestISub("Negative");
|
---|
251 |
|
---|
252 | RTPIPE hPipeR = (RTPIPE)1;
|
---|
253 | RTPIPE hPipeW = (RTPIPE)1;
|
---|
254 | RTTESTI_CHECK_RC(RTPipeCreate(&hPipeR, &hPipeW, ~0), VERR_INVALID_PARAMETER);
|
---|
255 | RTTESTI_CHECK_RC(RTPipeCreate(NULL, &hPipeW, 0), VERR_INVALID_POINTER);
|
---|
256 | RTTESTI_CHECK_RC(RTPipeCreate(&hPipeR, NULL, 0), VERR_INVALID_POINTER);
|
---|
257 | RTTESTI_CHECK(hPipeR == (RTPIPE)1);
|
---|
258 | RTTESTI_CHECK(hPipeW == (RTPIPE)1);
|
---|
259 |
|
---|
260 |
|
---|
261 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
262 |
|
---|
263 | char abBuf[_4K];
|
---|
264 | size_t cbRead = ~(size_t)3;
|
---|
265 | RTTESTI_CHECK_RC(RTPipeRead(hPipeW, abBuf, 0, &cbRead), VERR_ACCESS_DENIED);
|
---|
266 | RTTESTI_CHECK_RC(RTPipeRead(hPipeW, abBuf, 1, &cbRead), VERR_ACCESS_DENIED);
|
---|
267 | RTTESTI_CHECK(cbRead == ~(size_t)3);
|
---|
268 | RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeW, abBuf, 0, NULL), VERR_ACCESS_DENIED);
|
---|
269 | RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeW, abBuf, 1, NULL), VERR_ACCESS_DENIED);
|
---|
270 |
|
---|
271 | size_t cbWrite = ~(size_t)5;
|
---|
272 | RTTESTI_CHECK_RC(RTPipeWrite(hPipeR, "asdf", 0, &cbWrite), VERR_ACCESS_DENIED);
|
---|
273 | RTTESTI_CHECK_RC(RTPipeWrite(hPipeR, "asdf", 4, &cbWrite), VERR_ACCESS_DENIED);
|
---|
274 | RTTESTI_CHECK(cbWrite == ~(size_t)5);
|
---|
275 | RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeR, "asdf", 0, NULL), VERR_ACCESS_DENIED);
|
---|
276 | RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeR, "asdf", 4, NULL), VERR_ACCESS_DENIED);
|
---|
277 |
|
---|
278 | RTTESTI_CHECK_RC(RTPipeFlush(hPipeR), VERR_ACCESS_DENIED);
|
---|
279 |
|
---|
280 | RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
281 | RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
282 | }
|
---|
283 |
|
---|
284 |
|
---|
285 | static void tstRTPipe1(void)
|
---|
286 | {
|
---|
287 | RTTestISub("Basics");
|
---|
288 |
|
---|
289 | RTPIPE hPipeR = NIL_RTPIPE;
|
---|
290 | RTPIPE hPipeW = NIL_RTPIPE;
|
---|
291 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
292 | RTTESTI_CHECK_RETV(hPipeR != NIL_RTPIPE);
|
---|
293 | RTTESTI_CHECK_RETV(hPipeW != NIL_RTPIPE);
|
---|
294 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
295 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
296 | RTTESTI_CHECK_RC_RETV(RTPipeClose(NIL_RTPIPE), VINF_SUCCESS);
|
---|
297 |
|
---|
298 | hPipeR = NIL_RTPIPE;
|
---|
299 | hPipeW = NIL_RTPIPE;
|
---|
300 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ | RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
|
---|
301 | int rc = RTPipeFlush(hPipeW);
|
---|
302 | RTTESTI_CHECK_MSG(rc == VERR_NOT_SUPPORTED || rc == VINF_SUCCESS, ("%Rrc\n", rc));
|
---|
303 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
304 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
305 |
|
---|
306 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ), VINF_SUCCESS);
|
---|
307 | RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 0), VERR_TIMEOUT);
|
---|
308 | RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 1), VERR_TIMEOUT);
|
---|
309 | RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeW, 0), VINF_SUCCESS);
|
---|
310 | RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeW, 1), VINF_SUCCESS);
|
---|
311 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
312 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
313 |
|
---|
314 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
|
---|
315 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
316 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
317 |
|
---|
318 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ), VINF_SUCCESS);
|
---|
319 |
|
---|
320 | size_t cbRead = ~(size_t)0;
|
---|
321 | char abBuf[_64K + _4K];
|
---|
322 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VINF_TRY_AGAIN);
|
---|
323 | RTTESTI_CHECK_RETV(cbRead == 0);
|
---|
324 |
|
---|
325 | cbRead = ~(size_t)0;
|
---|
326 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 1, &cbRead), VINF_TRY_AGAIN);
|
---|
327 | RTTESTI_CHECK_RETV(cbRead == 0);
|
---|
328 |
|
---|
329 | cbRead = ~(size_t)0;
|
---|
330 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
|
---|
331 | RTTESTI_CHECK_RETV(cbRead == 0);
|
---|
332 |
|
---|
333 | size_t cbWritten = ~(size_t)2;
|
---|
334 | RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, abBuf, 0, &cbWritten), VINF_SUCCESS);
|
---|
335 | RTTESTI_CHECK_RETV(cbWritten == 0);
|
---|
336 |
|
---|
337 | /* We can write a number of bytes without blocking (see PIPE_BUF on
|
---|
338 | POSIX systems). */
|
---|
339 | cbWritten = ~(size_t)2;
|
---|
340 | RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "42", 2, &cbWritten), VINF_SUCCESS);
|
---|
341 | RTTESTI_CHECK_MSG_RETV(cbWritten == 2, ("cbWritten=%zu\n", cbWritten));
|
---|
342 | cbWritten = ~(size_t)2;
|
---|
343 | RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "!", 1, &cbWritten), VINF_SUCCESS);
|
---|
344 | RTTESTI_CHECK_RETV(cbWritten == 1);
|
---|
345 | cbRead = ~(size_t)0;
|
---|
346 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 3, &cbRead), VINF_SUCCESS);
|
---|
347 | RTTESTI_CHECK_RETV(cbRead == 3);
|
---|
348 | RTTESTI_CHECK_RETV(!memcmp(abBuf, "42!", 3));
|
---|
349 |
|
---|
350 | cbWritten = ~(size_t)2;
|
---|
351 | RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "BigQ", 4, &cbWritten), VINF_SUCCESS);
|
---|
352 | RTTESTI_CHECK_RETV(cbWritten == 4);
|
---|
353 | RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 0), VINF_SUCCESS);
|
---|
354 | RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 1), VINF_SUCCESS);
|
---|
355 | cbRead = ~(size_t)0;
|
---|
356 | RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
|
---|
357 | RTTESTI_CHECK_MSG(cbRead == cbWritten, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
|
---|
358 | cbRead = ~(size_t)0;
|
---|
359 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VINF_SUCCESS);
|
---|
360 | RTTESTI_CHECK_RETV(cbRead == 4);
|
---|
361 | RTTESTI_CHECK_RETV(!memcmp(abBuf, "BigQ", 4));
|
---|
362 |
|
---|
363 | cbWritten = ~(size_t)2;
|
---|
364 | RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "H2G2", 4, &cbWritten), VINF_SUCCESS);
|
---|
365 | RTTESTI_CHECK_RETV(cbWritten == 4);
|
---|
366 | cbRead = ~(size_t)0;
|
---|
367 | RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
|
---|
368 | RTTESTI_CHECK_MSG(cbRead == cbWritten, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
|
---|
369 | cbRead = ~(size_t)0;
|
---|
370 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
|
---|
371 | RTTESTI_CHECK_RETV(cbRead == 1);
|
---|
372 | cbRead = ~(size_t)0;
|
---|
373 | RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
|
---|
374 | RTTESTI_CHECK_MSG(cbRead == cbWritten - 1, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
|
---|
375 | cbRead = ~(size_t)0;
|
---|
376 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[1], 1, &cbRead), VINF_SUCCESS);
|
---|
377 | RTTESTI_CHECK_RETV(cbRead == 1);
|
---|
378 | cbRead = ~(size_t)0;
|
---|
379 | RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
|
---|
380 | RTTESTI_CHECK_MSG(cbRead == cbWritten - 2, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
|
---|
381 | cbRead = ~(size_t)0;
|
---|
382 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[2], 1, &cbRead), VINF_SUCCESS);
|
---|
383 | RTTESTI_CHECK_RETV(cbRead == 1);
|
---|
384 | cbRead = ~(size_t)0;
|
---|
385 | RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
|
---|
386 | RTTESTI_CHECK_MSG(cbRead == cbWritten - 3, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
|
---|
387 | cbRead = ~(size_t)0;
|
---|
388 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[3], 1, &cbRead), VINF_SUCCESS);
|
---|
389 | RTTESTI_CHECK_RETV(cbRead == 1);
|
---|
390 | RTTESTI_CHECK_RETV(!memcmp(abBuf, "H2G2", 4));
|
---|
391 | cbRead = ~(size_t)0;
|
---|
392 | RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
|
---|
393 | RTTESTI_CHECK_MSG(cbRead == cbWritten - 4, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
|
---|
394 |
|
---|
395 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
396 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
397 |
|
---|
398 |
|
---|
399 | RTTestISub("VERR_BROKEN_PIPE");
|
---|
400 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
401 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
402 | cbWritten = ~(size_t)2;
|
---|
403 | RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "", 0, &cbWritten), VINF_SUCCESS);
|
---|
404 | RTTESTI_CHECK(cbWritten == 0);
|
---|
405 | cbWritten = ~(size_t)2;
|
---|
406 | RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "4", 1, &cbWritten), VERR_BROKEN_PIPE);
|
---|
407 | RTTESTI_CHECK(cbWritten == ~(size_t)2);
|
---|
408 | RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
409 |
|
---|
410 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
411 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
412 | cbRead = ~(size_t)0;
|
---|
413 | RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
|
---|
414 | RTTESTI_CHECK(cbRead == 0);
|
---|
415 | cbRead = ~(size_t)3;
|
---|
416 | RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
|
---|
417 | RTTESTI_CHECK(cbRead == ~(size_t)3);
|
---|
418 | RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
419 |
|
---|
420 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
421 | cbWritten = ~(size_t)2;
|
---|
422 | RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "42", 2, &cbWritten), VINF_SUCCESS);
|
---|
423 | RTTESTI_CHECK(cbWritten == 2);
|
---|
424 | RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
425 | cbRead = ~(size_t)0;
|
---|
426 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
|
---|
427 | RTTESTI_CHECK(cbRead == 0);
|
---|
428 | cbRead = ~(size_t)0;
|
---|
429 | RTTESTI_CHECK_RC(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
|
---|
430 | RTTESTI_CHECK(cbRead == 1);
|
---|
431 | cbRead = ~(size_t)0;
|
---|
432 | RTTESTI_CHECK_RC(RTPipeRead(hPipeR, &abBuf[1], 1, &cbRead), VINF_SUCCESS);
|
---|
433 | RTTESTI_CHECK(cbRead == 1);
|
---|
434 | RTTESTI_CHECK(!memcmp(abBuf, "42", 2));
|
---|
435 | cbRead = ~(size_t)0;
|
---|
436 | RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
|
---|
437 | RTTESTI_CHECK(cbRead == 0);
|
---|
438 | cbRead = ~(size_t)3;
|
---|
439 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
|
---|
440 | RTTESTI_CHECK(cbRead == ~(size_t)3);
|
---|
441 | RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
442 |
|
---|
443 | RTTestISub("Blocking");
|
---|
444 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
445 | RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "42!", 3, &cbWritten), VINF_SUCCESS);
|
---|
446 | RTTESTI_CHECK(cbWritten == 3);
|
---|
447 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, abBuf, 3, NULL), VINF_SUCCESS);
|
---|
448 | RTTESTI_CHECK(!memcmp(abBuf, "42!", 3));
|
---|
449 | RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
450 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 0, NULL), VINF_SUCCESS);
|
---|
451 | cbRead = ~(size_t)42;
|
---|
452 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 0, &cbRead), VINF_SUCCESS);
|
---|
453 | RTTESTI_CHECK(cbRead == 0);
|
---|
454 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 1, NULL), VERR_BROKEN_PIPE);
|
---|
455 | cbRead = ~(size_t)42;
|
---|
456 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 1, &cbRead), VERR_BROKEN_PIPE);
|
---|
457 | RTTESTI_CHECK(cbRead == 0);
|
---|
458 | RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
459 |
|
---|
460 | RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
|
---|
461 | RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42!", 3, NULL), VINF_SUCCESS);
|
---|
462 | RTTESTI_CHECK(cbWritten == 3);
|
---|
463 | cbRead = ~(size_t)0;
|
---|
464 | RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
|
---|
465 | RTTESTI_CHECK(cbRead == 1);
|
---|
466 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[1], 1, NULL), VINF_SUCCESS);
|
---|
467 | RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[2], 1, NULL), VINF_SUCCESS);
|
---|
468 | RTTESTI_CHECK(!memcmp(abBuf, "42!", 3));
|
---|
469 | RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
|
---|
470 | RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "", 0, NULL), VINF_SUCCESS);
|
---|
471 | cbWritten = ~(size_t)9;
|
---|
472 | RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "", 0, &cbWritten), VINF_SUCCESS);
|
---|
473 | RTTESTI_CHECK(cbWritten == 0);
|
---|
474 | RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42", 2, NULL), VERR_BROKEN_PIPE);
|
---|
475 | cbWritten = ~(size_t)9;
|
---|
476 | RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42", 2, &cbWritten), VERR_BROKEN_PIPE);
|
---|
477 | RTTESTI_CHECK(cbWritten == 0);
|
---|
478 | RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
|
---|
479 | }
|
---|
480 |
|
---|
481 | int main(int argc, char **argv)
|
---|
482 | {
|
---|
483 | if (argc == 3 && !strcmp(argv[1], "--child-4"))
|
---|
484 | return tstRTPipe4Child(argv[2]);
|
---|
485 | if (argc == 3 && !strcmp(argv[1], "--child-5"))
|
---|
486 | return tstRTPipe5Child(argv[2]);
|
---|
487 |
|
---|
488 | RTTEST hTest;
|
---|
489 | int rc = RTTestInitAndCreate("tstRTPipe", &hTest);
|
---|
490 | if (rc)
|
---|
491 | return rc;
|
---|
492 | RTTestBanner(hTest);
|
---|
493 |
|
---|
494 | /*
|
---|
495 | * The tests.
|
---|
496 | */
|
---|
497 | tstRTPipe1();
|
---|
498 | if (RTTestErrorCount(hTest) == 0)
|
---|
499 | {
|
---|
500 | bool fMayPanic = RTAssertMayPanic();
|
---|
501 | bool fQuiet = RTAssertAreQuiet();
|
---|
502 | RTAssertSetMayPanic(false);
|
---|
503 | RTAssertSetQuiet(true);
|
---|
504 | tstRTPipe2();
|
---|
505 | RTAssertSetQuiet(fQuiet);
|
---|
506 | RTAssertSetMayPanic(fMayPanic);
|
---|
507 |
|
---|
508 | tstRTPipe3();
|
---|
509 | tstRTPipe4();
|
---|
510 | tstRTPipe5();
|
---|
511 | }
|
---|
512 |
|
---|
513 | /*
|
---|
514 | * Summary.
|
---|
515 | */
|
---|
516 | return RTTestSummaryAndDestroy(hTest);
|
---|
517 | }
|
---|
518 |
|
---|