1 /* GLib testing framework examples and tests
2 * Copyright (C) 2008 Red Hat, Inc
3 *
4 * This work is provided "as is"; redistribution and modification
5 * in whole or in part, in any medium, physical or electronic is
6 * permitted without restriction.
7 *
8 * This work is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * In no event shall the authors or contributors be liable for any
13 * direct, indirect, incidental, special, exemplary, or consequential
14 * damages (including, but not limited to, procurement of substitute
15 * goods or services; loss of use, data, or profits; or business
16 * interruption) however caused and on any theory of liability, whether
17 * in contract, strict liability, or tort (including negligence or
18 * otherwise) arising in any way out of the use of this software, even
19 * if advised of the possibility of such damage.
20 */
21
22 #include <glib/glib.h>
23 #include <gio/gio.h>
24 #include <gio/gwin32inputstream.h>
25 #include <gio/gwin32outputstream.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <fcntl.h>
29 #include <io.h>
30
31 #include <windows.h>
32
33 #define DATA "abcdefghijklmnopqrstuvwxyz"
34
35 int writer_pipe[2], reader_pipe[2];
36 GCancellable *writer_cancel, *reader_cancel, *main_cancel;
37 GMainLoop *loop;
38
39 static gpointer
writer_thread(gpointer user_data)40 writer_thread (gpointer user_data)
41 {
42 GOutputStream *out;
43 gssize nwrote, offset;
44 GError *err = NULL;
45 HANDLE out_handle;
46
47 g_assert (DuplicateHandle (GetCurrentProcess (),
48 (HANDLE) (gintptr) _get_osfhandle (writer_pipe[1]),
49 GetCurrentProcess (),
50 &out_handle,
51 0, FALSE,
52 DUPLICATE_SAME_ACCESS));
53 close (writer_pipe[1]);
54
55 out = g_win32_output_stream_new (out_handle, TRUE);
56 do
57 {
58 g_usleep (10);
59
60 offset = 0;
61 while (offset < (gssize) sizeof (DATA))
62 {
63 nwrote = g_output_stream_write (out, DATA + offset,
64 sizeof (DATA) - offset,
65 writer_cancel, &err);
66 if (nwrote <= 0 || err != NULL)
67 break;
68 offset += nwrote;
69 }
70
71 g_assert (nwrote > 0 || err != NULL);
72 }
73 while (err == NULL);
74
75 if (g_cancellable_is_cancelled (writer_cancel))
76 {
77 g_cancellable_cancel (main_cancel);
78 g_object_unref (out);
79 return NULL;
80 }
81
82 g_warning ("writer: %s", err->message);
83 g_assert_not_reached ();
84 }
85
86 static gpointer
reader_thread(gpointer user_data)87 reader_thread (gpointer user_data)
88 {
89 GInputStream *in;
90 gssize nread = 0, total;
91 GError *err = NULL;
92 char buf[sizeof (DATA)];
93 HANDLE in_handle;
94
95 g_assert (DuplicateHandle (GetCurrentProcess (),
96 (HANDLE) (gintptr) _get_osfhandle (reader_pipe[0]),
97 GetCurrentProcess (),
98 &in_handle,
99 0, FALSE,
100 DUPLICATE_SAME_ACCESS));
101 close (reader_pipe[0]);
102
103 in = g_win32_input_stream_new (in_handle, TRUE);
104
105 do
106 {
107 total = 0;
108 while (total < (gssize) sizeof (DATA))
109 {
110 nread = g_input_stream_read (in, buf + total, sizeof (buf) - total,
111 reader_cancel, &err);
112 if (nread <= 0 || err != NULL)
113 break;
114 total += nread;
115 }
116
117 if (err)
118 break;
119
120 if (nread == 0)
121 {
122 g_assert (err == NULL);
123 /* pipe closed */
124 g_object_unref (in);
125 return NULL;
126 }
127
128 g_assert_cmpstr (buf, ==, DATA);
129 g_assert (!g_cancellable_is_cancelled (reader_cancel));
130 }
131 while (err == NULL);
132
133 g_warning ("reader: %s", err->message);
134 g_assert_not_reached ();
135 }
136
137 char main_buf[sizeof (DATA)];
138 gssize main_len, main_offset;
139
140 static void readable (GObject *source, GAsyncResult *res, gpointer user_data);
141 static void writable (GObject *source, GAsyncResult *res, gpointer user_data);
142
143 static void
do_main_cancel(GOutputStream * out)144 do_main_cancel (GOutputStream *out)
145 {
146 g_output_stream_close (out, NULL, NULL);
147 g_main_loop_quit (loop);
148 }
149
150 static void
readable(GObject * source,GAsyncResult * res,gpointer user_data)151 readable (GObject *source, GAsyncResult *res, gpointer user_data)
152 {
153 GInputStream *in = G_INPUT_STREAM (source);
154 GOutputStream *out = user_data;
155 GError *err = NULL;
156
157 main_len = g_input_stream_read_finish (in, res, &err);
158
159 if (g_cancellable_is_cancelled (main_cancel))
160 {
161 do_main_cancel (out);
162 return;
163 }
164
165 g_assert (err == NULL);
166
167 main_offset = 0;
168 g_output_stream_write_async (out, main_buf, main_len,
169 G_PRIORITY_DEFAULT, main_cancel,
170 writable, in);
171 }
172
173 static void
writable(GObject * source,GAsyncResult * res,gpointer user_data)174 writable (GObject *source, GAsyncResult *res, gpointer user_data)
175 {
176 GOutputStream *out = G_OUTPUT_STREAM (source);
177 GInputStream *in = user_data;
178 GError *err = NULL;
179 gssize nwrote;
180
181 nwrote = g_output_stream_write_finish (out, res, &err);
182
183 if (g_cancellable_is_cancelled (main_cancel))
184 {
185 do_main_cancel (out);
186 return;
187 }
188
189 g_assert (err == NULL);
190 g_assert_cmpint (nwrote, <=, main_len - main_offset);
191
192 main_offset += nwrote;
193 if (main_offset == main_len)
194 {
195 g_input_stream_read_async (in, main_buf, sizeof (main_buf),
196 G_PRIORITY_DEFAULT, main_cancel,
197 readable, out);
198 }
199 else
200 {
201 g_output_stream_write_async (out, main_buf + main_offset,
202 main_len - main_offset,
203 G_PRIORITY_DEFAULT, main_cancel,
204 writable, in);
205 }
206 }
207
208 static gboolean
timeout(gpointer cancellable)209 timeout (gpointer cancellable)
210 {
211 g_cancellable_cancel (cancellable);
212 return FALSE;
213 }
214
215 static void
test_pipe_io(void)216 test_pipe_io (void)
217 {
218 GThread *writer, *reader;
219 GInputStream *in;
220 GOutputStream *out;
221 HANDLE in_handle, out_handle;
222
223 /* Split off two (additional) threads, a reader and a writer. From
224 * the writer thread, write data synchronously in small chunks,
225 * which gets read asynchronously by the main thread and then
226 * written asynchronously to the reader thread, which reads it
227 * synchronously. Eventually a timeout in the main thread will cause
228 * it to cancel the writer thread, which will in turn cancel the
229 * read op in the main thread, which will then close the pipe to
230 * the reader thread, causing the read op to fail.
231 */
232
233 g_assert (_pipe (writer_pipe, 10, _O_BINARY) == 0 && _pipe (reader_pipe, 10, _O_BINARY) == 0);
234
235 writer_cancel = g_cancellable_new ();
236 reader_cancel = g_cancellable_new ();
237 main_cancel = g_cancellable_new ();
238
239 writer = g_thread_new ("writer", writer_thread, NULL);
240 reader = g_thread_new ("reader", reader_thread, NULL);
241
242 g_assert (DuplicateHandle (GetCurrentProcess (),
243 (HANDLE) (gintptr) _get_osfhandle (writer_pipe[0]),
244 GetCurrentProcess (),
245 &in_handle,
246 0, FALSE,
247 DUPLICATE_SAME_ACCESS));
248 close (writer_pipe[0]);
249
250 g_assert (DuplicateHandle (GetCurrentProcess (),
251 (HANDLE) (gintptr) _get_osfhandle (reader_pipe[1]),
252 GetCurrentProcess (),
253 &out_handle,
254 0, FALSE,
255 DUPLICATE_SAME_ACCESS));
256 close (reader_pipe[1]);
257
258 in = g_win32_input_stream_new (in_handle, TRUE);
259 out = g_win32_output_stream_new (out_handle, TRUE);
260
261 g_input_stream_read_async (in, main_buf, sizeof (main_buf),
262 G_PRIORITY_DEFAULT, main_cancel,
263 readable, out);
264
265 g_timeout_add (500, timeout, writer_cancel);
266
267 loop = g_main_loop_new (NULL, TRUE);
268 g_main_loop_run (loop);
269 g_main_loop_unref (loop);
270
271 g_thread_join (reader);
272 g_thread_join (writer);
273
274 g_object_unref (main_cancel);
275 g_object_unref (reader_cancel);
276 g_object_unref (writer_cancel);
277 g_object_unref (in);
278 g_object_unref (out);
279 }
280
281 typedef struct _PipeIOOverlapReader
282 {
283 char buf[sizeof (DATA)];
284 GInputStream *in;
285 GThread *thread;
286 GCancellable *cancellable;
287 gboolean success;
288 } PipeIOOverlapReader;
289
290 #define TEST_PIPE_IO_OVERLAP (1024 * 4)
291
292 static gpointer
pipe_io_overlap_reader_thread(gpointer user_data)293 pipe_io_overlap_reader_thread (gpointer user_data)
294 {
295 PipeIOOverlapReader *p = user_data;
296 GError *err = NULL;
297 gsize read;
298 guint i;
299
300 for (i = 0; i < TEST_PIPE_IO_OVERLAP; ++i) {
301 memset (p->buf, 0, sizeof (p->buf));
302 g_input_stream_read_all (p->in, p->buf, sizeof (p->buf),
303 &read, NULL, &err);
304
305 g_assert_cmpuint (read, ==, sizeof (p->buf));
306 g_assert_no_error (err);
307 g_assert_cmpstr (p->buf, ==, DATA);
308 }
309
310 return NULL;
311 }
312
313 static gpointer
pipe_io_overlap_writer_thread(gpointer user_data)314 pipe_io_overlap_writer_thread (gpointer user_data)
315 {
316 GOutputStream *out = user_data;
317 GError *err = NULL;
318 gsize bytes_written;
319 guint i;
320
321 for (i = 0; i < TEST_PIPE_IO_OVERLAP; ++i) {
322 g_output_stream_write_all (out, DATA, sizeof (DATA),
323 &bytes_written, NULL, &err);
324
325 g_assert_cmpuint (bytes_written, ==, sizeof (DATA));
326 g_assert_no_error (err);
327 }
328
329 return NULL;
330 }
331
332 static void
test_pipe_io_overlap(void)333 test_pipe_io_overlap (void)
334 {
335 GOutputStream *out_server, *out_client;
336 GThread *writer_server, *writer_client;
337 PipeIOOverlapReader rs, rc;
338 HANDLE server, client;
339 gchar name[256];
340
341 g_snprintf (name, sizeof (name),
342 "\\\\.\\pipe\\gtest-io-overlap-%u", (guint) GetCurrentProcessId ());
343
344 server = CreateNamedPipe (name,
345 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
346 PIPE_READMODE_BYTE | PIPE_WAIT,
347 1, 0, 0, 0, NULL);
348 g_assert (server != INVALID_HANDLE_VALUE);
349
350 client = CreateFile (name, GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
351 g_assert (client != INVALID_HANDLE_VALUE);
352
353 out_server = g_win32_output_stream_new (server, TRUE);
354 writer_server = g_thread_new ("writer_server", pipe_io_overlap_writer_thread, out_server);
355 rs.in = g_win32_input_stream_new (server, TRUE);
356 rs.thread = g_thread_new ("reader_server", pipe_io_overlap_reader_thread, &rs);
357
358 out_client = g_win32_output_stream_new (client, TRUE);
359 writer_client = g_thread_new ("writer_client", pipe_io_overlap_writer_thread, out_client);
360 rc.in = g_win32_input_stream_new (client, TRUE);
361 rc.thread = g_thread_new ("reader_client", pipe_io_overlap_reader_thread, &rc);
362
363 g_thread_join (writer_client);
364 g_thread_join (writer_server);
365 g_thread_join (rc.thread);
366 g_thread_join (rs.thread);
367
368 g_object_unref (rs.in);
369 g_object_unref (rc.in);
370 g_object_unref (out_server);
371 g_object_unref (out_client);
372 }
373
374 static gpointer
pipe_io_concurrent_writer_thread(gpointer user_data)375 pipe_io_concurrent_writer_thread (gpointer user_data)
376 {
377 GOutputStream *out = user_data;
378 GError *err = NULL;
379 gsize bytes_written;
380
381 g_output_stream_write_all (out, DATA, 1, &bytes_written, NULL, &err);
382
383 g_assert_cmpuint (bytes_written, ==, 1);
384 g_assert_no_error (err);
385
386 return NULL;
387 }
388
389 static gpointer
pipe_io_concurrent_reader_thread(gpointer user_data)390 pipe_io_concurrent_reader_thread (gpointer user_data)
391 {
392 PipeIOOverlapReader *p = user_data;
393 GError *err = NULL;
394 gsize read;
395
396 memset (p->buf, 0, sizeof (p->buf));
397 p->success = g_input_stream_read_all (p->in, p->buf, 1, &read, p->cancellable, &err);
398
399 /* only one thread will succeed, the other will be cancelled */
400 if (p->success)
401 {
402 /* continue the main thread */
403 write (writer_pipe[1], "", 1);
404 g_assert_cmpuint (read, ==, 1);
405 g_assert_no_error (err);
406 }
407
408 return NULL;
409 }
410
411 static void
test_pipe_io_concurrent(void)412 test_pipe_io_concurrent (void)
413 {
414 GOutputStream *out_server;
415 GThread *writer_server;
416 PipeIOOverlapReader rc1, rc2;
417 HANDLE server, client;
418 gchar name[256], c;
419
420 g_snprintf (name, sizeof (name),
421 "\\\\.\\pipe\\gtest-io-concurrent-%u", (guint) GetCurrentProcessId ());
422
423 server = CreateNamedPipe (name,
424 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
425 PIPE_READMODE_BYTE | PIPE_WAIT,
426 1, 0, 0, 0, NULL);
427 g_assert (server != INVALID_HANDLE_VALUE);
428 g_assert (_pipe (writer_pipe, 10, _O_BINARY) == 0);
429
430 client = CreateFile (name, GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
431 g_assert (client != INVALID_HANDLE_VALUE);
432
433 rc1.in = g_win32_input_stream_new (client, TRUE);
434 rc1.success = FALSE;
435 rc1.cancellable = g_cancellable_new ();
436 rc1.thread = g_thread_new ("reader_client", pipe_io_concurrent_reader_thread, &rc1);
437
438 rc2.in = g_win32_input_stream_new (client, TRUE);
439 rc2.success = FALSE;
440 rc2.cancellable = g_cancellable_new ();
441 rc2.thread = g_thread_new ("reader_client", pipe_io_concurrent_reader_thread, &rc2);
442
443 /* FIXME: how to synchronize on both reader thread waiting in read,
444 before starting the writer thread? */
445 g_usleep (G_USEC_PER_SEC / 10);
446
447 out_server = g_win32_output_stream_new (server, TRUE);
448 writer_server = g_thread_new ("writer_server", pipe_io_concurrent_writer_thread, out_server);
449
450 read (writer_pipe[0], &c, 1);
451
452 g_assert (rc1.success ^ rc2.success);
453
454 g_cancellable_cancel (rc1.cancellable);
455 g_cancellable_cancel (rc2.cancellable);
456
457 g_thread_join (writer_server);
458 g_thread_join (rc1.thread);
459 g_thread_join (rc2.thread);
460
461 g_object_unref (rc1.in);
462 g_object_unref (rc2.in);
463 g_object_unref (out_server);
464
465 close (writer_pipe[0]);
466 close (writer_pipe[1]);
467 }
468
469 static void
readable_cancel(GObject * source,GAsyncResult * res,gpointer user_data)470 readable_cancel (GObject *source, GAsyncResult *res, gpointer user_data)
471 {
472 GInputStream *in = G_INPUT_STREAM (source);
473 GError *err = NULL;
474 gssize len;
475
476 len = g_input_stream_read_finish (in, res, &err);
477 g_assert_cmpint (len, ==, -1);
478 g_assert_error (err, G_IO_ERROR, G_IO_ERROR_CANCELLED);
479 g_error_free (err);
480
481 g_main_loop_quit (loop);
482 }
483
484 static void
test_pipe_io_cancel(void)485 test_pipe_io_cancel (void)
486 {
487 GInputStream *in;
488 GOutputStream *out;
489 HANDLE in_handle, out_handle;
490 gchar name[256];
491
492 g_snprintf (name, sizeof (name),
493 "\\\\.\\pipe\\gtest-io-cancel-%u", (guint) GetCurrentProcessId ());
494
495 in_handle = CreateNamedPipe (name,
496 PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
497 PIPE_READMODE_BYTE | PIPE_WAIT,
498 1, 0, 0, 0, NULL);
499 g_assert (in_handle != INVALID_HANDLE_VALUE);
500
501 out_handle = CreateFile (name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
502 g_assert (out_handle != INVALID_HANDLE_VALUE);
503
504 in = g_win32_input_stream_new (in_handle, TRUE);
505 out = g_win32_output_stream_new (out_handle, TRUE);
506
507 reader_cancel = g_cancellable_new ();
508 g_input_stream_read_async (in, main_buf, sizeof (main_buf),
509 G_PRIORITY_DEFAULT, reader_cancel,
510 readable_cancel, out);
511
512 g_timeout_add (500, timeout, reader_cancel);
513
514 loop = g_main_loop_new (NULL, TRUE);
515 g_main_loop_run (loop);
516 g_main_loop_unref (loop);
517
518 g_object_unref (reader_cancel);
519 g_object_unref (in);
520 g_object_unref (out);
521 }
522
523 int
main(int argc,char * argv[])524 main (int argc,
525 char *argv[])
526 {
527 g_test_init (&argc, &argv, NULL);
528
529 g_test_add_func ("/win32-streams/pipe-io-test", test_pipe_io);
530 g_test_add_func ("/win32-streams/pipe-io-cancel-test", test_pipe_io_cancel);
531 g_test_add_func ("/win32-streams/pipe-io-overlap-test", test_pipe_io_overlap);
532 g_test_add_func ("/win32-streams/pipe-io-concurrent-test", test_pipe_io_concurrent);
533
534 return g_test_run();
535 }
536