tstRTPoll.cpp@ 62571

Last change on this file since 62571 was 62477, checked in by vboxsync, 8 years ago
(C) 2016
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.5 KB

Line
1	/* $Id: tstRTPoll.cpp 62477 2016-07-22 18:27:37Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - RTPoll.
4	*/
5
6	/*
7	* Copyright (C) 2010-2016 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/poll.h>
32
33	#include <iprt/err.h>
34	#include <iprt/file.h>
35	#include <iprt/mem.h>
36	#include <iprt/pipe.h>
37	#include <iprt/string.h>
38	#include <iprt/test.h>
39
40
41	static void tstRTPoll2(void)
42	{
43	RTTestISub("Negative");
44
45	/*
46	* Bad set pointer and handle values.
47	*/
48	RTTESTI_CHECK_RC(RTPollSetCreate(NULL), VERR_INVALID_POINTER);
49	RTPOLLSET hSetInvl = (RTPOLLSET)(intptr_t)-3;
50	RTTESTI_CHECK_RC(RTPollSetDestroy(hSetInvl), VERR_INVALID_HANDLE);
51	RTHANDLE Handle;
52	Handle.enmType = RTHANDLETYPE_PIPE;
53	Handle.u.hPipe = NIL_RTPIPE;
54	RTTESTI_CHECK_RC(RTPollSetAdd(hSetInvl, &Handle, RTPOLL_EVT_ERROR, 1), VERR_INVALID_HANDLE);
55	RTTESTI_CHECK_RC(RTPollSetRemove(hSetInvl, 1), VERR_INVALID_HANDLE);
56	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSetInvl, 1, NULL), VERR_INVALID_HANDLE);
57	RTTESTI_CHECK(RTPollSetGetCount(hSetInvl) == UINT32_MAX);
58	RTTESTI_CHECK_RC(RTPoll(hSetInvl, 0, NULL, NULL), VERR_INVALID_HANDLE);
59	RTTESTI_CHECK_RC(RTPollNoResume(hSetInvl, 0, NULL, NULL), VERR_INVALID_HANDLE);
60
61	/*
62	* Invalid arguments and other stuff.
63	*/
64	RTPOLLSET hSet = NIL_RTPOLLSET;
65	RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
66
67	RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VERR_DEADLOCK);
68	RTTESTI_CHECK_RC(RTPollNoResume(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VERR_DEADLOCK);
69
70	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, UINT32_MAX), VERR_INVALID_PARAMETER);
71	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
72
73	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 1), VERR_POLL_HANDLE_ID_NOT_FOUND);
74
75	RTTESTI_CHECK_RC(RTPollSetAdd(hSet, NULL, RTPOLL_EVT_ERROR, 1), VINF_SUCCESS);
76	RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, RTPOLL_EVT_ERROR, UINT32_MAX), VERR_INVALID_PARAMETER);
77	RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, UINT32_MAX, 3), VERR_INVALID_PARAMETER);
78	Handle.enmType = RTHANDLETYPE_INVALID;
79	RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, RTPOLL_EVT_ERROR, 3), VERR_INVALID_PARAMETER);
80	RTTESTI_CHECK_RC(RTPollSetAdd(hSet, NULL, RTPOLL_EVT_ERROR, UINT32_MAX), VERR_INVALID_PARAMETER);
81
82	/* duplicate id */
83	RTPIPE hPipeR;
84	RTPIPE hPipeW;
85	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0/fFlags/), VINF_SUCCESS);
86	RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_ERROR, 0), VINF_SUCCESS);
87	RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_ERROR, 0), VERR_POLL_HANDLE_ID_EXISTS);
88	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 0), VINF_SUCCESS);
89	RTPipeClose(hPipeR);
90	RTPipeClose(hPipeW);
91
92	/* non-pollable handle */
93	RTFILE hBitBucket;
94	RTTESTI_CHECK_RC_RETV(RTFileOpenBitBucket(&hBitBucket, RTFILE_O_WRITE), VINF_SUCCESS);
95	Handle.enmType = RTHANDLETYPE_FILE;
96	Handle.u.hFile = hBitBucket;
97	RTTESTI_CHECK_RC(RTPollSetAdd(hSet, &Handle, RTPOLL_EVT_WRITE, 10), VERR_POLL_HANDLE_NOT_POLLABLE);
98	RTFileClose(hBitBucket);
99
100	RTTESTI_CHECK_RC_RETV(RTPollSetDestroy(hSet), VINF_SUCCESS);
101
102
103
104	}
105
106
107	static void tstRTPoll1(void)
108	{
109	RTTestISub("Basics");
110
111	/* create and destroy. */
112	RTPOLLSET hSet = NIL_RTPOLLSET;
113	RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
114	RTTESTI_CHECK_RETV(hSet != NIL_RTPOLLSET);
115	RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
116	RTTESTI_CHECK_RC(RTPollSetDestroy(NIL_RTPOLLSET), VINF_SUCCESS);
117
118	/* empty set, adding a NIL handle. */
119	hSet = NIL_RTPOLLSET;
120	RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
121	RTTESTI_CHECK_RETV(hSet != NIL_RTPOLLSET);
122
123	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 0);
124	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 0, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
125
126	RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, NIL_RTPIPE, RTPOLL_EVT_READ, 1 /id/), VINF_SUCCESS);
127	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 0);
128	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /id/, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
129	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 0), VERR_POLL_HANDLE_ID_NOT_FOUND);
130	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 0);
131
132	RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
133
134	/*
135	* Set with pipes
136	*/
137	RTPIPE hPipeR;
138	RTPIPE hPipeW;
139	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0/fFlags/), VINF_SUCCESS);
140
141	hSet = NIL_RTPOLLSET;
142	RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
143	RTTESTI_CHECK_RETV(hSet != NIL_RTPOLLSET);
144
145	/* add the read pipe */
146	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_READ, 1 /id/), VINF_SUCCESS);
147	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
148	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /id/, NULL), VINF_SUCCESS);
149	RTHANDLE Handle;
150	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 1 /id/, &Handle), VINF_SUCCESS);
151	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
152	RTTESTI_CHECK(Handle.u.hPipe == hPipeR);
153
154	/* poll on the set, should time out. */
155	RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VERR_TIMEOUT);
156	RTTESTI_CHECK_RC(RTPoll(hSet, 1, NULL, NULL), VERR_TIMEOUT);
157
158	/* add the write pipe with error detection only, check that poll still times out. remove it again. */
159	RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeW, RTPOLL_EVT_ERROR, 11 /id/), VINF_SUCCESS);
160	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 2);
161	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 11 /id/, NULL), VINF_SUCCESS);
162
163	RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VERR_TIMEOUT);
164	RTTESTI_CHECK_RC(RTPoll(hSet, 1, NULL, NULL), VERR_TIMEOUT);
165
166	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 11), VINF_SUCCESS);
167	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
168
169	/* add the write pipe */
170	RTTESTI_CHECK_RC(RTPollSetAddPipe(hSet, hPipeW, RTPOLL_EVT_WRITE, 10 /id/), VINF_SUCCESS);
171	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 2);
172	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 10 /id/, NULL), VINF_SUCCESS);
173
174	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /id/, &Handle), VINF_SUCCESS);
175	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
176	RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
177
178	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 1 /id/, &Handle), VINF_SUCCESS);
179	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
180	RTTESTI_CHECK(Handle.u.hPipe == hPipeR);
181
182	/* poll on the set again, now it should indicate hPipeW is ready. */
183	int rc;
184	RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
185	RTTESTI_CHECK_RC(rc = RTPoll(hSet, 100, NULL, NULL), VINF_SUCCESS);
186	if (RT_SUCCESS(rc))
187	RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VINF_SUCCESS);
188
189	RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 0, NULL, NULL), VINF_SUCCESS);
190	RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 100, NULL, NULL), VINF_SUCCESS);
191	if (RT_SUCCESS(rc))
192	RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, RT_INDEFINITE_WAIT, NULL, NULL), VINF_SUCCESS);
193
194	uint32_t fEvents = UINT32_MAX;
195	uint32_t id = UINT32_MAX;
196	RTTESTI_CHECK_RC(RTPoll(hSet, 0, &fEvents, &id), VINF_SUCCESS);
197	RTTESTI_CHECK(id == 10);
198	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
199
200	fEvents = UINT32_MAX;
201	id = UINT32_MAX;
202	RTTESTI_CHECK_RC(rc = RTPoll(hSet, 250, &fEvents, &id), VINF_SUCCESS);
203	RTTESTI_CHECK(id == 10);
204	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
205
206	if (RT_SUCCESS(rc))
207	{
208	fEvents = UINT32_MAX;
209	id = UINT32_MAX;
210	RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
211	RTTESTI_CHECK(id == 10);
212	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
213	}
214
215	fEvents = UINT32_MAX;
216	id = UINT32_MAX;
217	RTTESTI_CHECK_RC(RTPollNoResume(hSet, 0, &fEvents, &id), VINF_SUCCESS);
218	RTTESTI_CHECK(id == 10);
219	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
220
221	fEvents = UINT32_MAX;
222	id = UINT32_MAX;
223	RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 100, &fEvents, &id), VINF_SUCCESS);
224	RTTESTI_CHECK(id == 10);
225	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
226
227	if (RT_SUCCESS(rc))
228	{
229	fEvents = UINT32_MAX;
230	id = UINT32_MAX;
231	RTTESTI_CHECK_RC(RTPollNoResume(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
232	RTTESTI_CHECK(id == 10);
233	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
234	}
235
236	/* Write to the pipe. Currently ASSUMING we'll get the read ready now... Good idea? */
237	RTTESTI_CHECK_RC(rc = RTPipeWriteBlocking(hPipeW, "hello", 5, NULL), VINF_SUCCESS);
238	if (RT_SUCCESS(rc))
239	{
240	fEvents = UINT32_MAX;
241	id = UINT32_MAX;
242	RTTESTI_CHECK_RC(RTPoll(hSet, 0, &fEvents, &id), VINF_SUCCESS);
243	RTTESTI_CHECK(id == 1);
244	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
245
246	fEvents = UINT32_MAX;
247	id = UINT32_MAX;
248	RTTESTI_CHECK_RC(rc = RTPoll(hSet, 256, &fEvents, &id), VINF_SUCCESS);
249	RTTESTI_CHECK(id == 1);
250	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
251
252	if (RT_SUCCESS(rc))
253	{
254	fEvents = UINT32_MAX;
255	id = UINT32_MAX;
256	RTTESTI_CHECK_RC(RTPoll(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
257	RTTESTI_CHECK(id == 1);
258	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
259	}
260
261	fEvents = UINT32_MAX;
262	id = UINT32_MAX;
263	RTTESTI_CHECK_RC(RTPollNoResume(hSet, 0, &fEvents, &id), VINF_SUCCESS);
264	RTTESTI_CHECK(id == 1);
265	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
266
267	fEvents = UINT32_MAX;
268	id = UINT32_MAX;
269	RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 383, &fEvents, &id), VINF_SUCCESS);
270	RTTESTI_CHECK(id == 1);
271	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
272
273	if (RT_SUCCESS(rc))
274	{
275	fEvents = UINT32_MAX;
276	id = UINT32_MAX;
277	RTTESTI_CHECK_RC(RTPollNoResume(hSet, RT_INDEFINITE_WAIT, &fEvents, &id), VINF_SUCCESS);
278	RTTESTI_CHECK(id == 1);
279	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
280	}
281	}
282
283	/* Remove the read pipe, do a quick poll check. */
284	RTTESTI_CHECK_RC_RETV(RTPollSetRemove(hSet, 1), VINF_SUCCESS);
285	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
286	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /id/, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
287	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /id/, &Handle), VINF_SUCCESS);
288	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
289	RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
290
291	RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
292
293	/* Add it back and check that we now get the write handle when polling.
294	(Is this FIFOing a good idea?) */
295	RTTESTI_CHECK_RC_RETV(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
296
297	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_READ, 1 /id/), VINF_SUCCESS);
298	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 2);
299	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /id/, NULL), VINF_SUCCESS);
300
301	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 1 /id/, &Handle), VINF_SUCCESS);
302	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
303	RTTESTI_CHECK(Handle.u.hPipe == hPipeR);
304
305	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /id/, &Handle), VINF_SUCCESS);
306	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
307	RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
308
309	fEvents = UINT32_MAX;
310	id = UINT32_MAX;
311	RTTESTI_CHECK_RC(rc = RTPollNoResume(hSet, 555, &fEvents, &id), VINF_SUCCESS);
312	RTTESTI_CHECK(id == 10);
313	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
314
315	/* Remove it again and break the pipe by closing the read end. */
316	RTTESTI_CHECK_RC_RETV(RTPollSetRemove(hSet, 1), VINF_SUCCESS);
317	RTTESTI_CHECK_RETV(RTPollSetGetCount(hSet) == 1);
318	RTTESTI_CHECK_RC(RTPollSetQueryHandle(hSet, 1 /id/, NULL), VERR_POLL_HANDLE_ID_NOT_FOUND);
319	RTTESTI_CHECK_RC_RETV(RTPollSetQueryHandle(hSet, 10 /id/, &Handle), VINF_SUCCESS);
320	RTTESTI_CHECK(Handle.enmType == RTHANDLETYPE_PIPE);
321	RTTESTI_CHECK(Handle.u.hPipe == hPipeW);
322
323	RTTESTI_CHECK_RC(RTPoll(hSet, 0, NULL, NULL), VINF_SUCCESS);
324
325	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
326
327	fEvents = UINT32_MAX;
328	id = UINT32_MAX;
329	RTTESTI_CHECK_RC(RTPollNoResume(hSet, 0, &fEvents, &id), VINF_SUCCESS);
330	RTTESTI_CHECK(id == 10);
331	RTTESTI_CHECK_MSG( fEvents == RTPOLL_EVT_ERROR \
332	\|\| fEvents == (RTPOLL_EVT_ERROR \| RTPOLL_EVT_WRITE), ("%#x\n", fEvents));
333
334	RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
335	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
336
337	/*
338	* Check FIFO order when removing and adding.
339	*
340	* Note! FIFO order is not guaranteed when a handle has more than one entry
341	* in the set.
342	*/
343	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR, &hPipeW, 0/fFlags/), VINF_SUCCESS);
344	RTPIPE hPipeR2, hPipeW2;
345	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR2, &hPipeW2, 0/fFlags/), VINF_SUCCESS);
346	RTPIPE hPipeR3, hPipeW3;
347	RTTESTI_CHECK_RC_RETV(RTPipeCreate(&hPipeR3, &hPipeW3, 0/fFlags/), VINF_SUCCESS);
348	RTTESTI_CHECK_RC_RETV(RTPollSetCreate(&hSet), VINF_SUCCESS);
349	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR, RTPOLL_EVT_READ, 1 /id/), VINF_SUCCESS);
350	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeW, RTPOLL_EVT_WRITE, 2 /id/), VINF_SUCCESS);
351	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR2, RTPOLL_EVT_READ, 3 /id/), VINF_SUCCESS);
352	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeW2, RTPOLL_EVT_WRITE, 4 /id/), VINF_SUCCESS);
353	RTTESTI_CHECK_RC_RETV(RTPollSetAddPipe(hSet, hPipeR3, RTPOLL_EVT_READ, 5 /id/), VINF_SUCCESS);
354
355	id = UINT32_MAX; fEvents = UINT32_MAX;
356	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
357	RTTESTI_CHECK(id == 2);
358	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
359
360	RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW, "hello", 5, NULL), VINF_SUCCESS);
361	RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW2, "hello", 5, NULL), VINF_SUCCESS);
362	RTTESTI_CHECK_RC(RTPipeWriteBlocking(hPipeW3, "hello", 5, NULL), VINF_SUCCESS);
363	id = UINT32_MAX; fEvents = UINT32_MAX;
364	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
365	RTTESTI_CHECK(id == 1);
366	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
367
368	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 1), VINF_SUCCESS);
369	id = UINT32_MAX; fEvents = UINT32_MAX;
370	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
371	RTTESTI_CHECK(id == 2);
372	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
373
374	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 2), VINF_SUCCESS);
375	id = UINT32_MAX; fEvents = UINT32_MAX;
376	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
377	RTTESTI_CHECK(id == 3);
378	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
379
380	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 3), VINF_SUCCESS);
381	id = UINT32_MAX; fEvents = UINT32_MAX;
382	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
383	RTTESTI_CHECK(id == 4);
384	RTTESTI_CHECK(fEvents == RTPOLL_EVT_WRITE);
385
386	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 4), VINF_SUCCESS);
387	id = UINT32_MAX; fEvents = UINT32_MAX;
388	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VINF_SUCCESS);
389	RTTESTI_CHECK(id == 5);
390	RTTESTI_CHECK(fEvents == RTPOLL_EVT_READ);
391
392	RTTESTI_CHECK_RC(RTPollSetRemove(hSet, 5), VINF_SUCCESS);
393	id = UINT32_MAX; fEvents = UINT32_MAX;
394	RTTESTI_CHECK_RC(RTPoll(hSet, 5, &fEvents, &id), VERR_TIMEOUT);
395
396	RTTESTI_CHECK_RC(RTPipeClose(hPipeW), VINF_SUCCESS);
397	RTTESTI_CHECK_RC(RTPipeClose(hPipeR), VINF_SUCCESS);
398	RTTESTI_CHECK_RC(RTPipeClose(hPipeW2), VINF_SUCCESS);
399	RTTESTI_CHECK_RC(RTPipeClose(hPipeR2), VINF_SUCCESS);
400	RTTESTI_CHECK_RC(RTPipeClose(hPipeW3), VINF_SUCCESS);
401	RTTESTI_CHECK_RC(RTPipeClose(hPipeR3), VINF_SUCCESS);
402	RTTESTI_CHECK_RC(RTPollSetDestroy(hSet), VINF_SUCCESS);
403
404	}
405
406	int main()
407	{
408	RTTEST hTest;
409	int rc = RTTestInitAndCreate("tstRTPoll", &hTest);
410	if (rc)
411	return rc;
412	RTTestBanner(hTest);
413
414	/*
415	* The tests.
416	*/
417	tstRTPoll1();
418	if (RTTestErrorCount(hTest) == 0)
419	{
420	bool fMayPanic = RTAssertMayPanic();
421	bool fQuiet = RTAssertAreQuiet();
422	RTAssertSetMayPanic(false);
423	RTAssertSetQuiet(true);
424	tstRTPoll2();
425	RTAssertSetQuiet(fQuiet);
426	RTAssertSetMayPanic(fMayPanic);
427	}
428
429	/*
430	* Summary.
431	*/
432	return RTTestSummaryAndDestroy(hTest);
433	}
434

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

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTPoll.cpp@ 62571

Download in other formats: