VirtualBox

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

Last change on this file since 53582 was 28800, checked in by vboxsync, 15 years ago

Automated rebranding to Oracle copyright/license strings via filemuncher
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.4 KB
Line 
1/* $Id: tstRTPoll.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2/** @file
3 * IPRT Testcase - RTPoll.
4 */
5
6/*
7 * Copyright (C) 2010 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
41static 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
107static 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
406int 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.

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