VirtualBox

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

Last change on this file since 27123 was 26824, checked in by vboxsync, 15 years ago

iprt: Adjustments to RTPipeReadBlocking and RTPipeWriteBlocking. RTPoll and RTProcCreateEx testcases.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 13.5 KB
Line 
1/* $Id: tstRTPipe.cpp 26824 2010-02-26 10:36:08Z vboxsync $ */
2/** @file
3 * IPRT Testcase - RTPipe.
4 */
5
6/*
7 * Copyright (C) 2010 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31
32/*******************************************************************************
33* Header Files *
34*******************************************************************************/
35#include <iprt/pipe.h>
36
37#include <iprt/err.h>
38#include <iprt/mem.h>
39#include <iprt/string.h>
40#include <iprt/test.h>
41
42
43static void tstRTPipe3(void)
44{
45 RTTestISub("Full write buffer");
46
47 RTPIPE hPipeR = (RTPIPE)999999;
48 RTPIPE hPipeW = (RTPIPE)999999;
49 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
50
51 static char s_abBuf[_256K];
52 int rc = VINF_SUCCESS;
53 size_t cbTotal = 0;
54 memset(s_abBuf, 0xff, sizeof(s_abBuf));
55 for (;;)
56 {
57 RTTESTI_CHECK(cbTotal < _1G);
58 if (cbTotal > _1G)
59 break;
60
61 size_t cbWritten = _1G;
62 rc = RTPipeWrite(hPipeW, s_abBuf, sizeof(s_abBuf), &cbWritten);
63 RTTESTI_CHECK(rc == VINF_SUCCESS || rc == VINF_TRY_AGAIN);
64 if (rc != VINF_SUCCESS)
65 break;
66 cbTotal += cbWritten;
67 }
68
69 if (rc == VINF_TRY_AGAIN)
70 {
71 RTTestIPrintf(RTTESTLVL_ALWAYS, "cbTotal=%zu (%#zx)\n", cbTotal, cbTotal);
72 RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 0), VERR_TIMEOUT);
73 RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 1), VERR_TIMEOUT);
74 size_t cbRead;
75 RTTESTI_CHECK_RC(RTPipeRead(hPipeR, s_abBuf, RT_MIN(sizeof(s_abBuf), cbTotal) / 2, &cbRead), VINF_SUCCESS);
76 RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 0), VINF_SUCCESS);
77 RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 1), VINF_SUCCESS);
78
79 size_t cbWritten = _1G;
80 rc = RTPipeWrite(hPipeW, s_abBuf, sizeof(s_abBuf), &cbWritten);
81 RTTESTI_CHECK(rc == VINF_SUCCESS);
82 }
83
84 RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
85 RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
86}
87
88static void tstRTPipe2(void)
89{
90 RTTestISub("Negative");
91
92 RTPIPE hPipeR = (RTPIPE)1;
93 RTPIPE hPipeW = (RTPIPE)1;
94 RTTESTI_CHECK_RC(RTPipeCreate(&hPipeR, &hPipeW, ~0), VERR_INVALID_PARAMETER);
95 RTTESTI_CHECK_RC(RTPipeCreate(NULL, &hPipeW, 0), VERR_INVALID_POINTER);
96 RTTESTI_CHECK_RC(RTPipeCreate(&hPipeR, NULL, 0), VERR_INVALID_POINTER);
97 RTTESTI_CHECK(hPipeR == (RTPIPE)1);
98 RTTESTI_CHECK(hPipeW == (RTPIPE)1);
99
100
101 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
102
103 char abBuf[_4K];
104 size_t cbRead = ~(size_t)3;
105 RTTESTI_CHECK_RC(RTPipeRead(hPipeW, abBuf, 0, &cbRead), VERR_ACCESS_DENIED);
106 RTTESTI_CHECK_RC(RTPipeRead(hPipeW, abBuf, 1, &cbRead), VERR_ACCESS_DENIED);
107 RTTESTI_CHECK(cbRead == ~(size_t)3);
108 RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeW, abBuf, 0, NULL), VERR_ACCESS_DENIED);
109 RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeW, abBuf, 1, NULL), VERR_ACCESS_DENIED);
110
111 size_t cbWrite = ~(size_t)5;
112 RTTESTI_CHECK_RC(RTPipeWrite(hPipeR, "asdf", 0, &cbWrite), VERR_ACCESS_DENIED);
113 RTTESTI_CHECK_RC(RTPipeWrite(hPipeR, "asdf", 4, &cbWrite), VERR_ACCESS_DENIED);
114 RTTESTI_CHECK(cbWrite == ~(size_t)5);
115 RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeR, "asdf", 0, NULL), VERR_ACCESS_DENIED);
116 RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeR, "asdf", 4, NULL), VERR_ACCESS_DENIED);
117
118 RTTESTI_CHECK_RC(RTPipeFlush(hPipeR), VERR_ACCESS_DENIED);
119
120 RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
121 RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
122}
123
124
125static void tstRTPipe1(void)
126{
127 RTTestISub("Basics");
128
129 RTPIPE hPipeR = NIL_RTPIPE;
130 RTPIPE hPipeW = NIL_RTPIPE;
131 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
132 RTTESTI_CHECK_RETV(hPipeR != NIL_RTPIPE);
133 RTTESTI_CHECK_RETV(hPipeW != NIL_RTPIPE);
134 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
135 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
136 RTTESTI_CHECK_RC_RETV(RTPipeClose(NIL_RTPIPE), VINF_SUCCESS);
137
138 hPipeR = NIL_RTPIPE;
139 hPipeW = NIL_RTPIPE;
140 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ | RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
141 int rc = RTPipeFlush(hPipeW);
142 RTTESTI_CHECK_MSG(rc == VERR_NOT_SUPPORTED || rc == VINF_SUCCESS, ("%Rrc\n", rc));
143 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
144 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
145
146 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ), VINF_SUCCESS);
147 RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 0), VERR_TIMEOUT);
148 RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 1), VERR_TIMEOUT);
149 RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeW, 0), VINF_SUCCESS);
150 RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeW, 1), VINF_SUCCESS);
151 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
152 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
153
154 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
155 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
156 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
157
158 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ), VINF_SUCCESS);
159
160 size_t cbRead = ~(size_t)0;
161 char abBuf[_64K + _4K];
162 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VINF_TRY_AGAIN);
163 RTTESTI_CHECK_RETV(cbRead == 0);
164
165 cbRead = ~(size_t)0;
166 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 1, &cbRead), VINF_TRY_AGAIN);
167 RTTESTI_CHECK_RETV(cbRead == 0);
168
169 cbRead = ~(size_t)0;
170 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
171 RTTESTI_CHECK_RETV(cbRead == 0);
172
173 size_t cbWritten = ~(size_t)2;
174 RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, abBuf, 0, &cbWritten), VINF_SUCCESS);
175 RTTESTI_CHECK_RETV(cbWritten == 0);
176
177 /* We can write a number of bytes without blocking (see PIPE_BUF on
178 POSIX systems). */
179 cbWritten = ~(size_t)2;
180 RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "42", 2, &cbWritten), VINF_SUCCESS);
181 RTTESTI_CHECK_RETV(cbWritten == 2);
182 cbWritten = ~(size_t)2;
183 RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "!", 1, &cbWritten), VINF_SUCCESS);
184 RTTESTI_CHECK_RETV(cbWritten == 1);
185 cbRead = ~(size_t)0;
186 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 3, &cbRead), VINF_SUCCESS);
187 RTTESTI_CHECK_RETV(cbRead == 3);
188 RTTESTI_CHECK_RETV(!memcmp(abBuf, "42!", 3));
189
190 cbWritten = ~(size_t)2;
191 RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "BigQ", 4, &cbWritten), VINF_SUCCESS);
192 RTTESTI_CHECK_RETV(cbWritten == 4);
193 cbRead = ~(size_t)0;
194 RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 0), VINF_SUCCESS);
195 RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 1), VINF_SUCCESS);
196 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VINF_SUCCESS);
197 RTTESTI_CHECK_RETV(cbRead == 4);
198 RTTESTI_CHECK_RETV(!memcmp(abBuf, "BigQ", 4));
199
200 cbWritten = ~(size_t)2;
201 RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "H2G2", 4, &cbWritten), VINF_SUCCESS);
202 RTTESTI_CHECK_RETV(cbWritten == 4);
203 cbRead = ~(size_t)0;
204 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
205 RTTESTI_CHECK_RETV(cbRead == 1);
206 cbRead = ~(size_t)0;
207 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[1], 1, &cbRead), VINF_SUCCESS);
208 RTTESTI_CHECK_RETV(cbRead == 1);
209 cbRead = ~(size_t)0;
210 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[2], 1, &cbRead), VINF_SUCCESS);
211 RTTESTI_CHECK_RETV(cbRead == 1);
212 cbRead = ~(size_t)0;
213 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[3], 1, &cbRead), VINF_SUCCESS);
214 RTTESTI_CHECK_RETV(cbRead == 1);
215 RTTESTI_CHECK_RETV(!memcmp(abBuf, "H2G2", 4));
216
217 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
218 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
219
220
221 RTTestISub("VERR_BROKEN_PIPE");
222 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
223 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
224 cbWritten = ~(size_t)2;
225 RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "", 0, &cbWritten), VINF_SUCCESS);
226 RTTESTI_CHECK(cbWritten == 0);
227 cbWritten = ~(size_t)2;
228 RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "4", 1, &cbWritten), VERR_BROKEN_PIPE);
229 RTTESTI_CHECK(cbWritten == ~(size_t)2);
230 RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
231
232 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
233 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
234 cbRead = ~(size_t)0;
235 RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
236 RTTESTI_CHECK(cbRead == 0);
237 cbRead = ~(size_t)3;
238 RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
239 RTTESTI_CHECK(cbRead == ~(size_t)3);
240 RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
241
242 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
243 cbWritten = ~(size_t)2;
244 RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "42", 2, &cbWritten), VINF_SUCCESS);
245 RTTESTI_CHECK(cbWritten == 2);
246 RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
247 cbRead = ~(size_t)0;
248 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
249 RTTESTI_CHECK(cbRead == 0);
250 cbRead = ~(size_t)0;
251 RTTESTI_CHECK_RC(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
252 RTTESTI_CHECK(cbRead == 1);
253 cbRead = ~(size_t)0;
254 RTTESTI_CHECK_RC(RTPipeRead(hPipeR, &abBuf[1], 1, &cbRead), VINF_SUCCESS);
255 RTTESTI_CHECK(cbRead == 1);
256 RTTESTI_CHECK(!memcmp(abBuf, "42", 2));
257 cbRead = ~(size_t)0;
258 RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
259 RTTESTI_CHECK(cbRead == 0);
260 cbRead = ~(size_t)3;
261 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
262 RTTESTI_CHECK(cbRead == ~(size_t)3);
263 RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
264
265 RTTestISub("Blocking");
266 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
267 RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "42!", 3, &cbWritten), VINF_SUCCESS);
268 RTTESTI_CHECK(cbWritten == 3);
269 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, abBuf, 3, NULL), VINF_SUCCESS);
270 RTTESTI_CHECK(!memcmp(abBuf, "42!", 3));
271 RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
272 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 0, NULL), VINF_SUCCESS);
273 cbRead = ~(size_t)42;
274 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 0, &cbRead), VINF_SUCCESS);
275 RTTESTI_CHECK(cbRead == 0);
276 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 1, NULL), VERR_BROKEN_PIPE);
277 cbRead = ~(size_t)42;
278 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 1, &cbRead), VERR_BROKEN_PIPE);
279 RTTESTI_CHECK(cbRead == 0);
280 RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
281
282 RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
283 RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42!", 3, NULL), VINF_SUCCESS);
284 RTTESTI_CHECK(cbWritten == 3);
285 cbRead = ~(size_t)0;
286 RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
287 RTTESTI_CHECK(cbRead == 1);
288 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[1], 1, NULL), VINF_SUCCESS);
289 RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[2], 1, NULL), VINF_SUCCESS);
290 RTTESTI_CHECK(!memcmp(abBuf, "42!", 3));
291 RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
292 RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "", 0, NULL), VINF_SUCCESS);
293 cbWritten = ~(size_t)9;
294 RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "", 0, &cbWritten), VINF_SUCCESS);
295 RTTESTI_CHECK(cbWritten == 0);
296 RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42", 2, NULL), VERR_BROKEN_PIPE);
297 cbWritten = ~(size_t)9;
298 RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42", 2, &cbWritten), VERR_BROKEN_PIPE);
299 RTTESTI_CHECK(cbWritten == 0);
300 RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
301}
302
303int main()
304{
305 RTTEST hTest;
306 int rc = RTTestInitAndCreate("tstRTPipe", &hTest);
307 if (rc)
308 return rc;
309 RTTestBanner(hTest);
310
311 /*
312 * The tests.
313 */
314 tstRTPipe1();
315 if (RTTestErrorCount(hTest) == 0)
316 {
317 bool fMayPanic = RTAssertMayPanic();
318 bool fQuiet = RTAssertAreQuiet();
319 RTAssertSetMayPanic(false);
320 RTAssertSetQuiet(true);
321 tstRTPipe2();
322 RTAssertSetQuiet(fQuiet);
323 RTAssertSetMayPanic(fMayPanic);
324
325 tstRTPipe3();
326 }
327
328 /*
329 * Summary.
330 */
331 return RTTestSummaryAndDestroy(hTest);
332}
333
334
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