tstRTPipe.cpp@ 96205

Last change on this file since 96205 was 95096, checked in by vboxsync, 3 years ago
IPRT/pipe/win: Adjusted RTPipeSelectOne to account for the RTPipeWrite[Blocking] behaviour on windows, making tstRTPipe stop failing. Documented this in the pipe.h and the testcase.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.8 KB

Line
1	/* $Id: tstRTPipe.cpp 95096 2022-05-25 12:26:01Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - RTPipe.
4	*/
5
6	/*
7	* Copyright (C) 2010-2022 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	#ifdef RT_OS_WINDOWS
208	/* Kludge! The RTPipeWrite+RTPipeWriteBlocking code is able to write twice the size
209	of the pipe buffer, so the testcase won't behave right if we go lower
210	than 50% on the readback. */
211	for (unsigned uPct = 50; uPct < 100; uPct += 12)
212	#else
213	for (unsigned uPct = 25; uPct < 100; uPct += 12)
214	#endif
215	{
216	RTPIPE hPipeR = (RTPIPE)999999;
217	RTPIPE hPipeW = (RTPIPE)999999;
218	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
219	RTTestIErrContext("uPct=%d", uPct);
220
221	static char s_abBuf[_256K];
222	int rc = VINF_SUCCESS;
223	size_t cbTotal = 0;
224	memset(s_abBuf, 0xff, sizeof(s_abBuf));
225	for (;;)
226	{
227	RTTESTI_CHECK(cbTotal < _1G);
228	if (cbTotal > _1G)
229	break;
230
231	size_t cbWritten = _1G;
232	rc = RTPipeWrite(hPipeW, s_abBuf, sizeof(s_abBuf), &cbWritten);
233	RTTESTI_CHECK_MSG(rc == VINF_SUCCESS \|\| rc == VINF_TRY_AGAIN, ("rc=%Rrc\n", rc));
234	if (rc != VINF_SUCCESS)
235	break;
236	cbTotal += cbWritten;
237	}
238
239	if (rc == VINF_TRY_AGAIN)
240	{
241	size_t const cbToRead = RT_MIN(sizeof(s_abBuf), cbTotal * uPct / 100);
242	RTTestIPrintf(RTTESTLVL_ALWAYS, "cbTotal=%zu (%#zx) cbToRead=%zu (%#zx)\n", cbTotal, cbTotal, cbToRead, cbToRead);
243	RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 0), VERR_TIMEOUT);
244	RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 1), VERR_TIMEOUT);
245	size_t cbRead;
246	RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeR, s_abBuf, cbToRead, &cbRead), VINF_SUCCESS);
247	RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 0), VINF_SUCCESS);
248	RTTESTI_CHECK_RC(RTPipeSelectOne(hPipeW, 1), VINF_SUCCESS);
249
250	size_t cbWritten = _1G;
251	rc = RTPipeWrite(hPipeW, s_abBuf, sizeof(s_abBuf), &cbWritten);
252	RTTESTI_CHECK(rc == VINF_SUCCESS);
253	}
254
255	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
256	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
257	}
258	}
259
260	static void tstRTPipe2(void)
261	{
262	RTTestISub("Negative");
263
264	RTPIPE hPipeR = (RTPIPE)1;
265	RTPIPE hPipeW = (RTPIPE)1;
266	RTTESTI_CHECK_RC(RTPipeCreate(&hPipeR, &hPipeW, UINT32_MAX), VERR_INVALID_PARAMETER);
267	RTTESTI_CHECK_RC(RTPipeCreate(NULL, &hPipeW, 0), VERR_INVALID_POINTER);
268	RTTESTI_CHECK_RC(RTPipeCreate(&hPipeR, NULL, 0), VERR_INVALID_POINTER);
269	RTTESTI_CHECK(hPipeR == (RTPIPE)1);
270	RTTESTI_CHECK(hPipeW == (RTPIPE)1);
271
272
273	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
274
275	char abBuf[_4K];
276	size_t cbRead = ~(size_t)3;
277	RTTESTI_CHECK_RC(RTPipeRead(hPipeW, abBuf, 0, &cbRead), VERR_ACCESS_DENIED);
278	RTTESTI_CHECK_RC(RTPipeRead(hPipeW, abBuf, 1, &cbRead), VERR_ACCESS_DENIED);
279	RTTESTI_CHECK(cbRead == ~(size_t)3);
280	RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeW, abBuf, 0, NULL), VERR_ACCESS_DENIED);
281	RTTESTI_CHECK_RC(RTPipeReadBlocking(hPipeW, abBuf, 1, NULL), VERR_ACCESS_DENIED);
282
283	size_t cbWrite = ~(size_t)5;
284	RTTESTI_CHECK_RC(RTPipeWrite(hPipeR, "asdf", 0, &cbWrite), VERR_ACCESS_DENIED);
285	RTTESTI_CHECK_RC(RTPipeWrite(hPipeR, "asdf", 4, &cbWrite), VERR_ACCESS_DENIED);
286	RTTESTI_CHECK(cbWrite == ~(size_t)5);
287	RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeR, "asdf", 0, NULL), VERR_ACCESS_DENIED);
288	RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeR, "asdf", 4, NULL), VERR_ACCESS_DENIED);
289
290	RTTESTI_CHECK_RC(RTPipeFlush(hPipeR), VERR_ACCESS_DENIED);
291
292	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
293	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
294	}
295
296
297	static void tstRTPipe1(void)
298	{
299	RTTestISub("Basics");
300
301	RTPIPE hPipeR = NIL_RTPIPE;
302	RTPIPE hPipeW = NIL_RTPIPE;
303	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
304	RTTESTI_CHECK_RETV(hPipeR != NIL_RTPIPE);
305	RTTESTI_CHECK_RETV(hPipeW != NIL_RTPIPE);
306	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
307	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
308	RTTESTI_CHECK_RC_RETV(RTPipeClose(NIL_RTPIPE), VINF_SUCCESS);
309
310	hPipeR = NIL_RTPIPE;
311	hPipeW = NIL_RTPIPE;
312	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ \| RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
313	int rc = RTPipeFlush(hPipeW);
314	RTTESTI_CHECK_MSG(rc == VERR_NOT_SUPPORTED \|\| rc == VINF_SUCCESS, ("%Rrc\n", rc));
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	RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 0), VERR_TIMEOUT);
320	RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 1), VERR_TIMEOUT);
321	RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeW, 0), VINF_SUCCESS);
322	RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeW, 1), VINF_SUCCESS);
323	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
324	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
325
326	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_WRITE), VINF_SUCCESS);
327	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
328	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
329
330	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, RTPIPE_C_INHERIT_READ), VINF_SUCCESS);
331
332	size_t cbRead = ~(size_t)0;
333	char abBuf[_64K + _4K];
334	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VINF_TRY_AGAIN);
335	RTTESTI_CHECK_RETV(cbRead == 0);
336
337	cbRead = ~(size_t)0;
338	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 1, &cbRead), VINF_TRY_AGAIN);
339	RTTESTI_CHECK_RETV(cbRead == 0);
340
341	cbRead = ~(size_t)0;
342	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
343	RTTESTI_CHECK_RETV(cbRead == 0);
344
345	size_t cbWritten = ~(size_t)2;
346	RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, abBuf, 0, &cbWritten), VINF_SUCCESS);
347	RTTESTI_CHECK_RETV(cbWritten == 0);
348
349	/* We can write a number of bytes without blocking (see PIPE_BUF on
350	POSIX systems). */
351	cbWritten = ~(size_t)2;
352	RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "42", 2, &cbWritten), VINF_SUCCESS);
353	RTTESTI_CHECK_MSG_RETV(cbWritten == 2, ("cbWritten=%zu\n", cbWritten));
354	cbWritten = ~(size_t)2;
355	RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "!", 1, &cbWritten), VINF_SUCCESS);
356	RTTESTI_CHECK_RETV(cbWritten == 1);
357	cbRead = ~(size_t)0;
358	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 3, &cbRead), VINF_SUCCESS);
359	RTTESTI_CHECK_RETV(cbRead == 3);
360	RTTESTI_CHECK_RETV(!memcmp(abBuf, "42!", 3));
361
362	cbWritten = ~(size_t)2;
363	RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "BigQ", 4, &cbWritten), VINF_SUCCESS);
364	RTTESTI_CHECK_RETV(cbWritten == 4);
365	RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 0), VINF_SUCCESS);
366	RTTESTI_CHECK_RC_RETV(RTPipeSelectOne(hPipeR, 1), VINF_SUCCESS);
367	cbRead = ~(size_t)0;
368	RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
369	RTTESTI_CHECK_MSG(cbRead == cbWritten, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
370	cbRead = ~(size_t)0;
371	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VINF_SUCCESS);
372	RTTESTI_CHECK_RETV(cbRead == 4);
373	RTTESTI_CHECK_RETV(!memcmp(abBuf, "BigQ", 4));
374
375	cbWritten = ~(size_t)2;
376	RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "H2G2", 4, &cbWritten), VINF_SUCCESS);
377	RTTESTI_CHECK_RETV(cbWritten == 4);
378	cbRead = ~(size_t)0;
379	RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
380	RTTESTI_CHECK_MSG(cbRead == cbWritten, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
381	cbRead = ~(size_t)0;
382	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[0], 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 - 1, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
387	cbRead = ~(size_t)0;
388	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[1], 1, &cbRead), VINF_SUCCESS);
389	RTTESTI_CHECK_RETV(cbRead == 1);
390	cbRead = ~(size_t)0;
391	RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
392	RTTESTI_CHECK_MSG(cbRead == cbWritten - 2, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
393	cbRead = ~(size_t)0;
394	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[2], 1, &cbRead), VINF_SUCCESS);
395	RTTESTI_CHECK_RETV(cbRead == 1);
396	cbRead = ~(size_t)0;
397	RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
398	RTTESTI_CHECK_MSG(cbRead == cbWritten - 3, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
399	cbRead = ~(size_t)0;
400	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[3], 1, &cbRead), VINF_SUCCESS);
401	RTTESTI_CHECK_RETV(cbRead == 1);
402	RTTESTI_CHECK_RETV(!memcmp(abBuf, "H2G2", 4));
403	cbRead = ~(size_t)0;
404	RTTESTI_CHECK_RC_RETV(RTPipeQueryReadable(hPipeR, &cbRead), VINF_SUCCESS);
405	RTTESTI_CHECK_MSG(cbRead == cbWritten - 4, ("cbRead=%zu cbWritten=%zu\n", cbRead, cbWritten));
406
407	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
408	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
409
410
411	RTTestISub("VERR_BROKEN_PIPE");
412	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
413	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeR), VINF_SUCCESS);
414	cbWritten = ~(size_t)2;
415	RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "", 0, &cbWritten), VINF_SUCCESS);
416	RTTESTI_CHECK(cbWritten == 0);
417	cbWritten = ~(size_t)2;
418	RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "4", 1, &cbWritten), VERR_BROKEN_PIPE);
419	RTTESTI_CHECK(cbWritten == ~(size_t)2);
420	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
421
422	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
423	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
424	cbRead = ~(size_t)0;
425	RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
426	RTTESTI_CHECK(cbRead == 0);
427	cbRead = ~(size_t)3;
428	RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
429	RTTESTI_CHECK(cbRead == ~(size_t)3);
430	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
431
432	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
433	cbWritten = ~(size_t)2;
434	RTTESTI_CHECK_RC(RTPipeWrite(hPipeW, "42", 2, &cbWritten), VINF_SUCCESS);
435	RTTESTI_CHECK(cbWritten == 2);
436	RTTESTI_CHECK_RC_RETV(RTPipeClose(hPipeW), VINF_SUCCESS);
437	cbRead = ~(size_t)0;
438	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
439	RTTESTI_CHECK(cbRead == 0);
440	cbRead = ~(size_t)0;
441	RTTESTI_CHECK_RC(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
442	RTTESTI_CHECK(cbRead == 1);
443	cbRead = ~(size_t)0;
444	RTTESTI_CHECK_RC(RTPipeRead(hPipeR, &abBuf[1], 1, &cbRead), VINF_SUCCESS);
445	RTTESTI_CHECK(cbRead == 1);
446	RTTESTI_CHECK(!memcmp(abBuf, "42", 2));
447	cbRead = ~(size_t)0;
448	RTTESTI_CHECK_RC(RTPipeRead(hPipeR, abBuf, 0, &cbRead), VINF_SUCCESS);
449	RTTESTI_CHECK(cbRead == 0);
450	cbRead = ~(size_t)3;
451	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, abBuf, sizeof(abBuf), &cbRead), VERR_BROKEN_PIPE);
452	RTTESTI_CHECK(cbRead == ~(size_t)3);
453	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
454
455	RTTestISub("Blocking");
456	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
457	RTTESTI_CHECK_RC_RETV(RTPipeWrite(hPipeW, "42!", 3, &cbWritten), VINF_SUCCESS);
458	RTTESTI_CHECK(cbWritten == 3);
459	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, abBuf, 3, NULL), VINF_SUCCESS);
460	RTTESTI_CHECK(!memcmp(abBuf, "42!", 3));
461	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
462	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 0, NULL), VINF_SUCCESS);
463	cbRead = ~(size_t)42;
464	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 0, &cbRead), VINF_SUCCESS);
465	RTTESTI_CHECK(cbRead == 0);
466	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 1, NULL), VERR_BROKEN_PIPE);
467	cbRead = ~(size_t)42;
468	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[0], 1, &cbRead), VERR_BROKEN_PIPE);
469	RTTESTI_CHECK(cbRead == 0);
470	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
471
472	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0), VINF_SUCCESS);
473	RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42!", 3, NULL), VINF_SUCCESS);
474	RTTESTI_CHECK(cbWritten == 3);
475	cbRead = ~(size_t)0;
476	RTTESTI_CHECK_RC_RETV(RTPipeRead(hPipeR, &abBuf[0], 1, &cbRead), VINF_SUCCESS);
477	RTTESTI_CHECK(cbRead == 1);
478	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[1], 1, NULL), VINF_SUCCESS);
479	RTTESTI_CHECK_RC_RETV(RTPipeReadBlocking(hPipeR, &abBuf[2], 1, NULL), VINF_SUCCESS);
480	RTTESTI_CHECK(!memcmp(abBuf, "42!", 3));
481	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
482	RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "", 0, NULL), VINF_SUCCESS);
483	cbWritten = ~(size_t)9;
484	RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "", 0, &cbWritten), VINF_SUCCESS);
485	RTTESTI_CHECK(cbWritten == 0);
486	RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42", 2, NULL), VERR_BROKEN_PIPE);
487	cbWritten = ~(size_t)9;
488	RTTESTI_CHECK_RC_RETV(RTPipeWriteBlocking(hPipeW, "42", 2, &cbWritten), VERR_BROKEN_PIPE);
489	RTTESTI_CHECK(cbWritten == 0);
490	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
491	}
492
493	int main(int argc, char **argv)
494	{
495	if (argc == 3 && !strcmp(argv[1], "--child-4"))
496	return tstRTPipe4Child(argv[2]);
497	if (argc == 3 && !strcmp(argv[1], "--child-5"))
498	return tstRTPipe5Child(argv[2]);
499
500	RTTEST hTest;
501	int rc = RTTestInitAndCreate("tstRTPipe", &hTest);
502	if (rc)
503	return rc;
504	RTTestBanner(hTest);
505
506	/*
507	* The tests.
508	*/
509	tstRTPipe1();
510	if (RTTestErrorCount(hTest) == 0)
511	{
512	bool fMayPanic = RTAssertMayPanic();
513	bool fQuiet = RTAssertAreQuiet();
514	RTAssertSetMayPanic(false);
515	RTAssertSetQuiet(true);
516	tstRTPipe2();
517	RTAssertSetQuiet(fQuiet);
518	RTAssertSetMayPanic(fMayPanic);
519
520	tstRTPipe3();
521	tstRTPipe4();
522	tstRTPipe5();
523	}
524
525	/*
526	* Summary.
527	*/
528	return RTTestSummaryAndDestroy(hTest);
529	}
530

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: