1 /* GLib testing framework examples and tests
3 * Copyright (C) 2008-2011 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
26 #include <gio/gnetworking.h>
27 #include <gio/gunixconnection.h>
30 #include "gnetworkingprivate.h"
32 static gboolean ipv6_supported;
40 GCancellable *cancellable; /* to shut down dgram echo server thread */
44 echo_server_dgram_thread (gpointer user_data)
46 IPTestData *data = user_data;
48 GCancellable *cancellable = data->cancellable;
58 nread = g_socket_receive_from (sock, &sa, buf, sizeof (buf), cancellable, &error);
59 if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
61 g_assert_no_error (error);
62 g_assert_cmpint (nread, >=, 0);
64 nwrote = g_socket_send_to (sock, sa, buf, nread, cancellable, &error);
65 if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
67 g_assert_no_error (error);
68 g_assert_cmpint (nwrote, ==, nread);
73 g_clear_error (&error);
79 echo_server_thread (gpointer user_data)
81 IPTestData *data = user_data;
87 sock = g_socket_accept (data->server, NULL, &error);
88 g_assert_no_error (error);
92 nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
93 g_assert_no_error (error);
94 g_assert_cmpint (nread, >=, 0);
99 nwrote = g_socket_send (sock, buf, nread, NULL, &error);
100 g_assert_no_error (error);
101 g_assert_cmpint (nwrote, ==, nread);
104 g_socket_close (sock, &error);
105 g_assert_no_error (error);
106 g_object_unref (sock);
111 create_server_full (GSocketFamily family,
112 GSocketType socket_type,
113 GThreadFunc server_thread,
118 GError *error = NULL;
119 GSocketAddress *addr;
122 data = g_slice_new (IPTestData);
123 data->family = family;
125 data->server = server = g_socket_new (family,
127 G_SOCKET_PROTOCOL_DEFAULT,
129 g_assert_no_error (error);
131 g_assert_cmpint (g_socket_get_family (server), ==, family);
132 g_assert_cmpint (g_socket_get_socket_type (server), ==, socket_type);
133 g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
135 g_socket_set_blocking (server, TRUE);
137 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
140 g_socket_set_option (data->server, IPPROTO_IPV6, IPV6_V6ONLY, FALSE, NULL);
141 if (! g_socket_speaks_ipv4 (data->server))
143 g_object_unref (data->server);
144 g_slice_free (IPTestData, data);
151 iaddr = g_inet_address_new_any (family);
153 iaddr = g_inet_address_new_loopback (family);
154 addr = g_inet_socket_address_new (iaddr, 0);
155 g_object_unref (iaddr);
157 g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
158 g_socket_bind (server, addr, TRUE, &error);
159 g_assert_no_error (error);
160 g_object_unref (addr);
162 addr = g_socket_get_local_address (server, &error);
163 g_assert_no_error (error);
164 g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
165 g_object_unref (addr);
167 if (socket_type == G_SOCKET_TYPE_STREAM)
169 g_socket_listen (server, &error);
170 g_assert_no_error (error);
174 data->cancellable = g_cancellable_new ();
177 data->thread = g_thread_new ("server", server_thread, data);
183 create_server (GSocketFamily family,
184 GThreadFunc server_thread,
187 return create_server_full (family, G_SOCKET_TYPE_STREAM, server_thread, v4mapped);
190 static const gchar *testbuf = "0123456789abcdef";
193 test_ip_async_read_ready (GSocket *client,
197 IPTestData *data = user_data;
198 GError *error = NULL;
202 g_assert_cmpint (cond, ==, G_IO_IN);
204 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
205 g_assert_no_error (error);
206 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
208 g_assert_cmpstr (testbuf, ==, buf);
210 g_main_loop_quit (data->loop);
216 test_ip_async_write_ready (GSocket *client,
220 IPTestData *data = user_data;
221 GError *error = NULL;
225 g_assert_cmpint (cond, ==, G_IO_OUT);
227 len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
228 g_assert_no_error (error);
229 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
231 source = g_socket_create_source (client, G_IO_IN, NULL);
232 g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
234 g_source_attach (source, NULL);
235 g_source_unref (source);
241 test_ip_async_timed_out (GSocket *client,
245 IPTestData *data = user_data;
246 GError *error = NULL;
251 if (data->family == G_SOCKET_FAMILY_IPV4)
253 g_assert_cmpint (cond, ==, G_IO_IN);
254 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
255 g_assert_cmpint (len, ==, -1);
256 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
257 g_clear_error (&error);
260 source = g_socket_create_source (client, G_IO_OUT, NULL);
261 g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
263 g_source_attach (source, NULL);
264 g_source_unref (source);
270 test_ip_async_connected (GSocket *client,
274 IPTestData *data = user_data;
275 GError *error = NULL;
280 g_socket_check_connect_result (client, &error);
281 g_assert_no_error (error);
282 /* We do this after the check_connect_result, since that will give a
283 * more useful assertion in case of error.
285 g_assert_cmpint (cond, ==, G_IO_OUT);
287 g_assert (g_socket_is_connected (client));
289 /* This adds 1 second to "make check", so let's just only do it once. */
290 if (data->family == G_SOCKET_FAMILY_IPV4)
292 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
293 g_assert_cmpint (len, ==, -1);
294 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
295 g_clear_error (&error);
297 source = g_socket_create_source (client, G_IO_IN, NULL);
298 g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
300 g_source_attach (source, NULL);
301 g_source_unref (source);
304 test_ip_async_timed_out (client, 0, data);
310 idle_test_ip_async_connected (gpointer user_data)
312 IPTestData *data = user_data;
314 return test_ip_async_connected (data->client, G_IO_OUT, data);
318 test_ip_async (GSocketFamily family)
321 GError *error = NULL;
323 GSocketAddress *addr;
328 data = create_server (family, echo_server_thread, FALSE);
329 addr = g_socket_get_local_address (data->server, &error);
330 g_assert_no_error (error);
332 client = g_socket_new (family,
333 G_SOCKET_TYPE_STREAM,
334 G_SOCKET_PROTOCOL_DEFAULT,
336 g_assert_no_error (error);
337 data->client = client;
339 g_assert_cmpint (g_socket_get_family (client), ==, family);
340 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
341 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
343 g_socket_set_blocking (client, FALSE);
344 g_socket_set_timeout (client, 1);
346 if (g_socket_connect (client, addr, NULL, &error))
348 g_assert_no_error (error);
349 g_idle_add (idle_test_ip_async_connected, data);
353 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
354 g_clear_error (&error);
355 source = g_socket_create_source (client, G_IO_OUT, NULL);
356 g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
358 g_source_attach (source, NULL);
359 g_source_unref (source);
361 g_object_unref (addr);
363 data->loop = g_main_loop_new (NULL, TRUE);
364 g_main_loop_run (data->loop);
365 g_main_loop_unref (data->loop);
367 g_socket_shutdown (client, FALSE, TRUE, &error);
368 g_assert_no_error (error);
370 g_thread_join (data->thread);
372 if (family == G_SOCKET_FAMILY_IPV4)
374 /* Test that reading on a remote-closed socket gets back 0 bytes. */
375 len = g_socket_receive_with_blocking (client, buf, sizeof (buf),
377 g_assert_no_error (error);
378 g_assert_cmpint (len, ==, 0);
382 /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
383 len = g_socket_send_with_blocking (client, testbuf, strlen (testbuf) + 1,
385 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
386 g_assert_cmpint (len, ==, -1);
387 g_clear_error (&error);
390 g_socket_close (client, &error);
391 g_assert_no_error (error);
392 g_socket_close (data->server, &error);
393 g_assert_no_error (error);
395 g_object_unref (data->server);
396 g_object_unref (client);
398 g_slice_free (IPTestData, data);
402 test_ipv4_async (void)
404 test_ip_async (G_SOCKET_FAMILY_IPV4);
408 test_ipv6_async (void)
412 g_test_skip ("No support for IPv6");
416 test_ip_async (G_SOCKET_FAMILY_IPV6);
419 static const gchar testbuf2[] = "0123456789abcdefghijklmnopqrstuvwxyz";
422 test_ip_sync (GSocketFamily family)
425 GError *error = NULL;
427 GSocketAddress *addr;
431 data = create_server (family, echo_server_thread, FALSE);
432 addr = g_socket_get_local_address (data->server, &error);
433 g_assert_no_error (error);
435 client = g_socket_new (family,
436 G_SOCKET_TYPE_STREAM,
437 G_SOCKET_PROTOCOL_DEFAULT,
439 g_assert_no_error (error);
441 g_assert_cmpint (g_socket_get_family (client), ==, family);
442 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
443 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
445 g_socket_set_blocking (client, TRUE);
446 g_socket_set_timeout (client, 1);
448 g_socket_connect (client, addr, NULL, &error);
449 g_assert_no_error (error);
450 g_assert (g_socket_is_connected (client));
451 g_object_unref (addr);
453 /* This adds 1 second to "make check", so let's just only do it once. */
454 if (family == G_SOCKET_FAMILY_IPV4)
456 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
457 g_assert_cmpint (len, ==, -1);
458 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
459 g_clear_error (&error);
462 len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
463 g_assert_no_error (error);
464 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
466 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
467 g_assert_no_error (error);
468 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
470 g_assert_cmpstr (testbuf, ==, buf);
473 GOutputVector v[7] = { { NULL, }, };
475 v[0].buffer = testbuf2 + 0;
477 v[1].buffer = testbuf2 + 3;
479 v[2].buffer = testbuf2 + 3 + 5;
481 v[3].buffer = testbuf2 + 3 + 5;
483 v[4].buffer = testbuf2 + 3 + 5 + 6;
485 v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
487 v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
488 v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
490 len = g_socket_send_message (client, NULL, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
491 g_assert_no_error (error);
492 g_assert_cmpint (len, ==, strlen (testbuf2));
494 memset (buf, 0, sizeof (buf));
495 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
496 g_assert_no_error (error);
497 g_assert_cmpint (len, ==, strlen (testbuf2));
498 g_assert_cmpstr (testbuf2, ==, buf);
501 g_socket_shutdown (client, FALSE, TRUE, &error);
502 g_assert_no_error (error);
504 g_thread_join (data->thread);
506 if (family == G_SOCKET_FAMILY_IPV4)
508 /* Test that reading on a remote-closed socket gets back 0 bytes. */
509 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
510 g_assert_no_error (error);
511 g_assert_cmpint (len, ==, 0);
515 /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
516 len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
517 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
518 g_assert_cmpint (len, ==, -1);
519 g_clear_error (&error);
522 g_socket_close (client, &error);
523 g_assert_no_error (error);
524 g_socket_close (data->server, &error);
525 g_assert_no_error (error);
527 g_object_unref (data->server);
528 g_object_unref (client);
530 g_slice_free (IPTestData, data);
534 test_ipv4_sync (void)
536 test_ip_sync (G_SOCKET_FAMILY_IPV4);
540 test_ipv6_sync (void)
544 g_test_skip ("No support for IPv6");
548 test_ip_sync (G_SOCKET_FAMILY_IPV6);
552 test_ip_sync_dgram (GSocketFamily family)
555 GError *error = NULL;
557 GSocketAddress *dest_addr;
561 data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
562 echo_server_dgram_thread, FALSE);
564 dest_addr = g_socket_get_local_address (data->server, &error);
566 client = g_socket_new (family,
567 G_SOCKET_TYPE_DATAGRAM,
568 G_SOCKET_PROTOCOL_DEFAULT,
570 g_assert_no_error (error);
572 g_assert_cmpint (g_socket_get_family (client), ==, family);
573 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
574 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
576 g_socket_set_blocking (client, TRUE);
577 g_socket_set_timeout (client, 1);
579 len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);
580 g_assert_no_error (error);
581 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
583 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
584 g_assert_no_error (error);
585 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
587 g_assert_cmpstr (testbuf, ==, buf);
590 GOutputMessage m[3] = { { NULL, }, };
591 GInputMessage im[3] = { { NULL, }, };
592 GOutputVector v[7] = { { NULL, }, };
593 GInputVector iv[7] = { { NULL, }, };
595 v[0].buffer = testbuf2 + 0;
597 v[1].buffer = testbuf2 + 3;
599 v[2].buffer = testbuf2 + 3 + 5;
601 v[3].buffer = testbuf2 + 3 + 5;
603 v[4].buffer = testbuf2 + 3 + 5 + 6;
605 v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
607 v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
608 v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
610 iv[0].buffer = buf + 0;
612 iv[1].buffer = buf + 3;
614 iv[2].buffer = buf + 3 + 5;
616 iv[3].buffer = buf + 3 + 5;
618 iv[4].buffer = buf + 3 + 5 + 6;
620 iv[5].buffer = buf + 3 + 5 + 6 + 2;
622 iv[6].buffer = buf + 3 + 5 + 6 + 2 + 1;
623 iv[6].size = sizeof (buf) - (3 + 5 + 6 + 2 + 1);
625 len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
626 g_assert_no_error (error);
627 g_assert_cmpint (len, ==, strlen (testbuf2));
629 memset (buf, 0, sizeof (buf));
630 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
631 g_assert_no_error (error);
632 g_assert_cmpint (len, ==, strlen (testbuf2));
633 g_assert_cmpstr (testbuf2, ==, buf);
635 m[0].vectors = &v[0];
636 m[0].num_vectors = 1;
637 m[0].address = dest_addr;
638 m[1].vectors = &v[0];
639 m[1].num_vectors = 6;
640 m[1].address = dest_addr;
641 m[2].vectors = &v[6];
642 m[2].num_vectors = 1;
643 m[2].address = dest_addr;
645 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
646 g_assert_no_error (error);
647 g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
648 g_assert_cmpint (m[0].bytes_sent, ==, 3);
649 g_assert_cmpint (m[1].bytes_sent, ==, 17);
650 g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
652 memset (buf, 0, sizeof (buf));
653 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
654 g_assert_no_error (error);
655 g_assert_cmpint (len, ==, 3);
657 memset (buf, 0, sizeof (buf));
658 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
659 g_assert_no_error (error);
660 /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
661 g_assert_cmpint (len, ==, 17);
662 g_assert (memcmp (testbuf2, buf, 17) == 0);
664 memset (buf, 0, sizeof (buf));
665 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
666 g_assert_no_error (error);
667 g_assert_cmpint (len, ==, v[6].size);
668 g_assert_cmpstr (buf, ==, v[6].buffer);
670 /* reset since we're re-using the message structs */
675 /* now try receiving multiple messages */
676 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
677 g_assert_no_error (error);
678 g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
679 g_assert_cmpint (m[0].bytes_sent, ==, 3);
680 g_assert_cmpint (m[1].bytes_sent, ==, 17);
681 g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
683 im[0].vectors = &iv[0];
684 im[0].num_vectors = 1;
685 im[1].vectors = &iv[0];
686 im[1].num_vectors = 6;
687 im[2].vectors = &iv[6];
688 im[2].num_vectors = 1;
690 memset (buf, 0, sizeof (buf));
691 len = g_socket_receive_messages (client, im, G_N_ELEMENTS (im), 0,
693 g_assert_no_error (error);
694 g_assert_cmpint (len, ==, G_N_ELEMENTS (im));
696 g_assert_cmpuint (im[0].bytes_received, ==, 3);
697 /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
698 g_assert_cmpuint (im[1].bytes_received, ==, 17);
699 g_assert_cmpuint (im[2].bytes_received, ==, v[6].size);
701 /* reset since we're re-using the message structs */
706 /* now try to generate an early return by omitting the destination address on [1] */
708 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
709 g_assert_no_error (error);
710 g_assert_cmpint (len, ==, 1);
712 g_assert_cmpint (m[0].bytes_sent, ==, 3);
713 g_assert_cmpint (m[1].bytes_sent, ==, 0);
714 g_assert_cmpint (m[2].bytes_sent, ==, 0);
716 /* reset since we're re-using the message structs */
721 /* now try to generate an error by omitting all destination addresses */
725 len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
726 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
727 g_clear_error (&error);
728 g_assert_cmpint (len, ==, -1);
730 g_assert_cmpint (m[0].bytes_sent, ==, 0);
731 g_assert_cmpint (m[1].bytes_sent, ==, 0);
732 g_assert_cmpint (m[2].bytes_sent, ==, 0);
734 len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
735 g_assert_cmpint (len, ==, 3);
738 g_cancellable_cancel (data->cancellable);
740 g_thread_join (data->thread);
742 g_socket_close (client, &error);
743 g_assert_no_error (error);
744 g_socket_close (data->server, &error);
745 g_assert_no_error (error);
747 g_object_unref (data->server);
748 g_object_unref (data->cancellable);
749 g_object_unref (client);
750 g_object_unref (dest_addr);
752 g_slice_free (IPTestData, data);
756 test_ipv4_sync_dgram (void)
758 test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
762 test_ipv6_sync_dgram (void)
766 g_test_skip ("No support for IPv6");
770 test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
774 cancellable_thread_cb (gpointer data)
776 GCancellable *cancellable = data;
778 g_usleep (0.1 * G_USEC_PER_SEC);
779 g_cancellable_cancel (cancellable);
780 g_object_unref (cancellable);
786 test_ip_sync_dgram_timeouts (GSocketFamily family)
788 GError *error = NULL;
789 GSocket *client = NULL;
790 GCancellable *cancellable = NULL;
791 GThread *cancellable_thread = NULL;
794 client = g_socket_new (family,
795 G_SOCKET_TYPE_DATAGRAM,
796 G_SOCKET_PROTOCOL_DEFAULT,
798 g_assert_no_error (error);
800 g_assert_cmpint (g_socket_get_family (client), ==, family);
801 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
802 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
804 /* No overall timeout: test the per-operation timeouts instead. */
805 g_socket_set_timeout (client, 0);
807 cancellable = g_cancellable_new ();
809 /* Check for timeouts when no server is running. */
812 GInputMessage im = { NULL, };
813 GInputVector iv = { NULL, };
817 iv.size = sizeof (buf);
822 memset (buf, 0, sizeof (buf));
824 /* Try a non-blocking read. */
825 g_socket_set_blocking (client, FALSE);
826 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
828 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
829 g_assert_cmpint (len, ==, -1);
830 g_clear_error (&error);
832 /* Try a timeout read. Can’t really validate the time taken more than
833 * checking it’s positive. */
834 g_socket_set_timeout (client, 1);
835 g_socket_set_blocking (client, TRUE);
836 start_time = g_get_monotonic_time ();
837 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
839 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
840 g_assert_cmpint (len, ==, -1);
841 g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
842 g_clear_error (&error);
844 /* Try a blocking read, cancelled from another thread. */
845 g_socket_set_timeout (client, 0);
846 cancellable_thread = g_thread_new ("cancellable",
847 cancellable_thread_cb,
848 g_object_ref (cancellable));
850 start_time = g_get_monotonic_time ();
851 len = g_socket_receive_messages (client, &im, 1, 0 /* flags */,
852 cancellable, &error);
853 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
854 g_assert_cmpint (len, ==, -1);
855 g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
856 g_clear_error (&error);
858 g_thread_join (cancellable_thread);
861 g_socket_close (client, &error);
862 g_assert_no_error (error);
864 g_object_unref (client);
865 g_object_unref (cancellable);
869 test_ipv4_sync_dgram_timeouts (void)
871 test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);
875 test_ipv6_sync_dgram_timeouts (void)
879 g_test_skip ("No support for IPv6");
883 test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV6);
887 graceful_server_thread (gpointer user_data)
889 IPTestData *data = user_data;
891 GError *error = NULL;
894 sock = g_socket_accept (data->server, NULL, &error);
895 g_assert_no_error (error);
897 len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
898 g_assert_no_error (error);
899 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
905 test_close_graceful (void)
907 GSocketFamily family = G_SOCKET_FAMILY_IPV4;
909 GError *error = NULL;
910 GSocket *client, *server;
911 GSocketAddress *addr;
915 data = create_server (family, graceful_server_thread, FALSE);
916 addr = g_socket_get_local_address (data->server, &error);
917 g_assert_no_error (error);
919 client = g_socket_new (family,
920 G_SOCKET_TYPE_STREAM,
921 G_SOCKET_PROTOCOL_DEFAULT,
923 g_assert_no_error (error);
925 g_assert_cmpint (g_socket_get_family (client), ==, family);
926 g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
927 g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
929 g_socket_set_blocking (client, TRUE);
930 g_socket_set_timeout (client, 1);
932 g_socket_connect (client, addr, NULL, &error);
933 g_assert_no_error (error);
934 g_assert (g_socket_is_connected (client));
935 g_object_unref (addr);
937 server = g_thread_join (data->thread);
939 /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
940 g_socket_shutdown (server, FALSE, TRUE, &error);
941 g_assert_no_error (error);
943 /* we must timeout */
944 g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
945 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
946 g_clear_error (&error);
948 /* check that the remaining data is received */
949 len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
950 g_assert_no_error (error);
951 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
953 /* and only then the connection is closed */
954 len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
955 g_assert_no_error (error);
956 g_assert_cmpint (len, ==, 0);
958 g_socket_close (server, &error);
959 g_assert_no_error (error);
961 g_socket_close (client, &error);
962 g_assert_no_error (error);
964 g_object_unref (server);
965 g_object_unref (data->server);
966 g_object_unref (client);
968 g_slice_free (IPTestData, data);
971 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
973 v4mapped_server_thread (gpointer user_data)
975 IPTestData *data = user_data;
977 GError *error = NULL;
978 GSocketAddress *addr;
980 sock = g_socket_accept (data->server, NULL, &error);
981 g_assert_no_error (error);
983 g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
985 addr = g_socket_get_local_address (sock, &error);
986 g_assert_no_error (error);
987 g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
988 g_object_unref (addr);
990 addr = g_socket_get_remote_address (sock, &error);
991 g_assert_no_error (error);
992 g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
993 g_object_unref (addr);
995 g_socket_close (sock, &error);
996 g_assert_no_error (error);
997 g_object_unref (sock);
1002 test_ipv6_v4mapped (void)
1005 GError *error = NULL;
1007 GSocketAddress *addr, *v4addr;
1008 GInetAddress *iaddr;
1010 if (!ipv6_supported)
1012 g_test_skip ("No support for IPv6");
1016 data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
1020 g_test_message ("Test not run: not supported by the OS");
1024 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1025 G_SOCKET_TYPE_STREAM,
1026 G_SOCKET_PROTOCOL_DEFAULT,
1028 g_assert_no_error (error);
1030 g_socket_set_blocking (client, TRUE);
1031 g_socket_set_timeout (client, 1);
1033 addr = g_socket_get_local_address (data->server, &error);
1034 g_assert_no_error (error);
1035 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1036 v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
1037 g_object_unref (iaddr);
1038 g_object_unref (addr);
1040 g_socket_connect (client, v4addr, NULL, &error);
1041 g_assert_no_error (error);
1042 g_assert (g_socket_is_connected (client));
1044 g_thread_join (data->thread);
1046 g_socket_close (client, &error);
1047 g_assert_no_error (error);
1048 g_socket_close (data->server, &error);
1049 g_assert_no_error (error);
1051 g_object_unref (data->server);
1052 g_object_unref (client);
1053 g_object_unref (v4addr);
1055 g_slice_free (IPTestData, data);
1060 test_timed_wait (void)
1063 GError *error = NULL;
1065 GSocketAddress *addr;
1069 data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE);
1070 addr = g_socket_get_local_address (data->server, &error);
1071 g_assert_no_error (error);
1073 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1074 G_SOCKET_TYPE_STREAM,
1075 G_SOCKET_PROTOCOL_DEFAULT,
1077 g_assert_no_error (error);
1079 g_socket_set_blocking (client, TRUE);
1080 g_socket_set_timeout (client, 1);
1082 g_socket_connect (client, addr, NULL, &error);
1083 g_assert_no_error (error);
1084 g_object_unref (addr);
1086 start_time = g_get_monotonic_time ();
1087 g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
1089 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1090 g_clear_error (&error);
1091 poll_duration = g_get_monotonic_time () - start_time;
1093 g_assert_cmpint (poll_duration, >=, 98000);
1094 g_assert_cmpint (poll_duration, <, 112000);
1096 g_socket_close (client, &error);
1097 g_assert_no_error (error);
1099 g_thread_join (data->thread);
1101 g_socket_close (data->server, &error);
1102 g_assert_no_error (error);
1104 g_object_unref (data->server);
1105 g_object_unref (client);
1107 g_slice_free (IPTestData, data);
1111 duplicate_fd (int fd)
1116 if (!DuplicateHandle (GetCurrentProcess (),
1118 GetCurrentProcess (),
1122 DUPLICATE_SAME_ACCESS))
1134 test_fd_reuse (void)
1137 GError *error = NULL;
1140 GSocketAddress *addr;
1145 g_test_bug ("741707");
1147 data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE);
1148 addr = g_socket_get_local_address (data->server, &error);
1149 g_assert_no_error (error);
1151 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1152 G_SOCKET_TYPE_STREAM,
1153 G_SOCKET_PROTOCOL_DEFAULT,
1155 g_assert_no_error (error);
1157 g_socket_set_blocking (client, TRUE);
1158 g_socket_set_timeout (client, 1);
1160 g_socket_connect (client, addr, NULL, &error);
1161 g_assert_no_error (error);
1162 g_assert (g_socket_is_connected (client));
1163 g_object_unref (addr);
1165 /* we have to dup otherwise the fd gets closed twice on unref */
1166 fd = duplicate_fd (g_socket_get_fd (client));
1167 client2 = g_socket_new_from_fd (fd, &error);
1168 g_assert_no_error (error);
1170 g_assert_cmpint (g_socket_get_family (client2), ==, g_socket_get_family (client));
1171 g_assert_cmpint (g_socket_get_socket_type (client2), ==, g_socket_get_socket_type (client));
1172 g_assert_cmpint (g_socket_get_protocol (client2), ==, G_SOCKET_PROTOCOL_TCP);
1174 len = g_socket_send (client2, testbuf, strlen (testbuf) + 1, NULL, &error);
1175 g_assert_no_error (error);
1176 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1178 len = g_socket_receive (client2, buf, sizeof (buf), NULL, &error);
1179 g_assert_no_error (error);
1180 g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1182 g_assert_cmpstr (testbuf, ==, buf);
1184 g_socket_shutdown (client, FALSE, TRUE, &error);
1185 g_assert_no_error (error);
1186 /* The semantics of dup()+shutdown() are ambiguous; this call will succeed
1187 * on Linux, but return ENOTCONN on OS X.
1189 g_socket_shutdown (client2, FALSE, TRUE, NULL);
1191 g_thread_join (data->thread);
1193 g_socket_close (client, &error);
1194 g_assert_no_error (error);
1195 g_socket_close (client2, &error);
1196 g_assert_no_error (error);
1197 g_socket_close (data->server, &error);
1198 g_assert_no_error (error);
1200 g_object_unref (data->server);
1201 g_object_unref (client);
1202 g_object_unref (client2);
1204 g_slice_free (IPTestData, data);
1208 test_sockaddr (void)
1210 struct sockaddr_in6 sin6, gsin6;
1211 GSocketAddress *saddr;
1212 GInetSocketAddress *isaddr;
1213 GInetAddress *iaddr;
1214 GError *error = NULL;
1216 memset (&sin6, 0, sizeof (sin6));
1217 sin6.sin6_family = AF_INET6;
1218 sin6.sin6_addr = in6addr_loopback;
1219 sin6.sin6_port = g_htons (42);
1220 sin6.sin6_scope_id = 17;
1221 sin6.sin6_flowinfo = 1729;
1223 saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
1224 g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
1226 isaddr = G_INET_SOCKET_ADDRESS (saddr);
1227 iaddr = g_inet_socket_address_get_address (isaddr);
1228 g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
1229 g_assert (g_inet_address_get_is_loopback (iaddr));
1231 g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
1232 g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
1233 g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
1235 g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
1236 g_assert_no_error (error);
1238 g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
1239 g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
1240 g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
1241 g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
1243 g_object_unref (saddr);
1248 test_unix_from_fd (void)
1254 fd = socket (AF_UNIX, SOCK_STREAM, 0);
1255 g_assert_cmpint (fd, !=, -1);
1258 s = g_socket_new_from_fd (fd, &error);
1259 g_assert_no_error (error);
1260 g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
1261 g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
1262 g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
1267 test_unix_connection (void)
1272 GSocketConnection *c;
1274 fd = socket (AF_UNIX, SOCK_STREAM, 0);
1275 g_assert_cmpint (fd, !=, -1);
1278 s = g_socket_new_from_fd (fd, &error);
1279 g_assert_no_error (error);
1280 c = g_socket_connection_factory_create_connection (s);
1281 g_assert (G_IS_UNIX_CONNECTION (c));
1286 static GSocketConnection *
1287 create_connection_for_fd (int fd)
1291 GSocketConnection *connection;
1293 socket = g_socket_new_from_fd (fd, &err);
1294 g_assert_no_error (err);
1295 g_assert (G_IS_SOCKET (socket));
1296 connection = g_socket_connection_factory_create_connection (socket);
1297 g_assert (G_IS_UNIX_CONNECTION (connection));
1298 g_object_unref (socket);
1302 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1305 test_unix_connection_ancillary_data (void)
1309 gint status, fd, len;
1314 g_assert_cmpint (status, ==, 0);
1316 status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1317 g_assert_cmpint (status, ==, 0);
1320 g_assert_cmpint (pid, >=, 0);
1322 /* Child: close its copy of the write end of the pipe, receive it
1323 * again from the parent over the socket, and write some text to it.
1325 * Parent: send the write end of the pipe (still open for the
1326 * parent) over the socket, close it, and read some text from the
1327 * read end of the pipe.
1331 GSocketConnection *connection;
1334 connection = create_connection_for_fd (sv[0]);
1336 status = close (pv[1]);
1337 g_assert_cmpint (status, ==, 0);
1340 fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1342 g_assert_no_error (err);
1343 g_assert_cmpint (fd, >, -1);
1344 g_object_unref (connection);
1347 len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1348 while (len == -1 && errno == EINTR);
1349 g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1354 GSocketConnection *connection;
1357 connection = create_connection_for_fd (sv[1]);
1360 g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1362 g_assert_no_error (err);
1363 g_object_unref (connection);
1365 status = close (pv[1]);
1366 g_assert_cmpint (status, ==, 0);
1368 memset (buffer, 0xff, sizeof buffer);
1370 len = read (pv[0], buffer, sizeof buffer);
1371 while (len == -1 && errno == EINTR);
1373 g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1374 g_assert_cmpstr (buffer, ==, TEST_DATA);
1376 waitpid (pid, &status, 0);
1377 g_assert (WIFEXITED (status));
1378 g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1381 /* TODO: add test for g_unix_connection_send_credentials() and
1382 * g_unix_connection_receive_credentials().
1385 #endif /* G_OS_UNIX */
1388 test_reuse_tcp (void)
1390 GSocket *sock1, *sock2;
1391 GError *error = NULL;
1392 GInetAddress *iaddr;
1393 GSocketAddress *addr;
1395 sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1396 G_SOCKET_TYPE_STREAM,
1397 G_SOCKET_PROTOCOL_DEFAULT,
1399 g_assert_no_error (error);
1401 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1402 addr = g_inet_socket_address_new (iaddr, 0);
1403 g_object_unref (iaddr);
1404 g_socket_bind (sock1, addr, TRUE, &error);
1405 g_object_unref (addr);
1406 g_assert_no_error (error);
1408 g_socket_listen (sock1, &error);
1409 g_assert_no_error (error);
1411 sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1412 G_SOCKET_TYPE_STREAM,
1413 G_SOCKET_PROTOCOL_DEFAULT,
1415 g_assert_no_error (error);
1417 addr = g_socket_get_local_address (sock1, &error);
1418 g_assert_no_error (error);
1419 g_socket_bind (sock2, addr, TRUE, &error);
1420 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1421 g_clear_error (&error);
1422 g_object_unref (addr);
1424 g_object_unref (sock1);
1425 g_object_unref (sock2);
1429 test_reuse_udp (void)
1431 GSocket *sock1, *sock2;
1432 GError *error = NULL;
1433 GInetAddress *iaddr;
1434 GSocketAddress *addr;
1436 sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1437 G_SOCKET_TYPE_DATAGRAM,
1438 G_SOCKET_PROTOCOL_DEFAULT,
1440 g_assert_no_error (error);
1442 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1443 addr = g_inet_socket_address_new (iaddr, 0);
1444 g_object_unref (iaddr);
1445 g_socket_bind (sock1, addr, TRUE, &error);
1446 g_object_unref (addr);
1447 g_assert_no_error (error);
1449 sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1450 G_SOCKET_TYPE_DATAGRAM,
1451 G_SOCKET_PROTOCOL_DEFAULT,
1453 g_assert_no_error (error);
1455 addr = g_socket_get_local_address (sock1, &error);
1456 g_assert_no_error (error);
1457 g_socket_bind (sock2, addr, TRUE, &error);
1458 g_object_unref (addr);
1459 g_assert_no_error (error);
1461 g_object_unref (sock1);
1462 g_object_unref (sock2);
1466 test_get_available (gconstpointer user_data)
1468 GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1470 GSocket *listener, *server, *client;
1472 GSocketAddress *saddr;
1473 gchar data[] = "0123456789abcdef";
1477 listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1479 G_SOCKET_PROTOCOL_DEFAULT,
1481 g_assert_no_error (err);
1482 g_assert (G_IS_SOCKET (listener));
1484 client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1486 G_SOCKET_PROTOCOL_DEFAULT,
1488 g_assert_no_error (err);
1489 g_assert (G_IS_SOCKET (client));
1491 if (socket_type == G_SOCKET_TYPE_STREAM)
1493 g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1494 g_assert_no_error (err);
1497 addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1498 saddr = g_inet_socket_address_new (addr, 0);
1500 g_socket_bind (listener, saddr, TRUE, &err);
1501 g_assert_no_error (err);
1502 g_object_unref (saddr);
1503 g_object_unref (addr);
1505 saddr = g_socket_get_local_address (listener, &err);
1506 g_assert_no_error (err);
1508 if (socket_type == G_SOCKET_TYPE_STREAM)
1510 g_socket_listen (listener, &err);
1511 g_assert_no_error (err);
1512 g_socket_connect (client, saddr, NULL, &err);
1513 g_assert_no_error (err);
1515 server = g_socket_accept (listener, NULL, &err);
1516 g_assert_no_error (err);
1517 g_socket_set_blocking (server, FALSE);
1518 g_object_unref (listener);
1523 g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1524 g_assert_no_error (err);
1526 while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1528 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1530 g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1531 g_assert_no_error (err);
1533 /* We need to wait until the data has actually been copied into the
1534 * server socket's buffers, but g_socket_condition_wait() won't help
1535 * here since the socket is definitely already readable. So there's
1536 * a race condition in checking its available bytes. In the TCP
1537 * case, we poll for a bit until the new data shows up. In the UDP
1538 * case, there's not much we can do, but at least the failure mode
1539 * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1541 if (socket_type == G_SOCKET_TYPE_STREAM)
1545 for (tries = 0; tries < 100; tries++)
1547 if (g_socket_get_available_bytes (server) > sizeof (data))
1552 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1557 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1560 g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1561 nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1562 g_assert_no_error (err);
1564 if (socket_type == G_SOCKET_TYPE_STREAM)
1566 g_assert_cmpint (nread, ==, 2 * sizeof (data));
1567 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1571 g_assert_cmpint (nread, ==, sizeof (data));
1572 g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1575 nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1576 if (socket_type == G_SOCKET_TYPE_STREAM)
1578 g_assert_cmpint (nread, ==, -1);
1579 g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1580 g_clear_error (&err);
1584 g_assert_cmpint (nread, ==, sizeof (data));
1585 g_assert_no_error (err);
1588 g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1590 g_socket_close (server, &err);
1591 g_assert_no_error (err);
1593 g_object_unref (saddr);
1594 g_object_unref (server);
1595 g_object_unref (client);
1603 GError *error = NULL;
1605 g_test_init (&argc, &argv, NULL);
1606 g_test_bug_base ("https://bugzilla.gnome.org/");
1608 sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
1609 G_SOCKET_TYPE_STREAM,
1610 G_SOCKET_PROTOCOL_DEFAULT,
1614 ipv6_supported = TRUE;
1615 g_object_unref (sock);
1619 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1620 g_clear_error (&error);
1623 g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
1624 g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
1625 g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
1626 g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
1627 g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
1628 g_test_add_func ("/socket/ipv4_sync/datagram/timeouts", test_ipv4_sync_dgram_timeouts);
1629 g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
1630 g_test_add_func ("/socket/ipv6_sync/datagram/timeouts", test_ipv6_sync_dgram_timeouts);
1631 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1632 g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
1634 g_test_add_func ("/socket/close_graceful", test_close_graceful);
1635 g_test_add_func ("/socket/timed_wait", test_timed_wait);
1636 g_test_add_func ("/socket/fd_reuse", test_fd_reuse);
1637 g_test_add_func ("/socket/address", test_sockaddr);
1639 g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
1640 g_test_add_func ("/socket/unix-connection", test_unix_connection);
1641 g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
1643 g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
1644 g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
1645 g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
1646 test_get_available);
1647 g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
1648 test_get_available);
1650 return g_test_run();