VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTPipe.cpp@ 91886

Last change on this file since 91886 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.2 KB
Line 
1/* $Id: tstRTPipe.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * IPRT Testcase - RTPipe.
4 */
5
6/*
7 * Copyright (C) 2010-2020 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*********************************************************************************************************************************/
47static const char g_szTest4Message[] = "This is test #4, everything is working fine.\n\r";
48static const char g_szTest5Message[] = "This is test #5, everything is working fine.\n\r";
49
50
51static 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
91static 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
128static 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
154static 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
203static 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
248static 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, UINT32_MAX), 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
285static 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
481int 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
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette