gio/tests/socket-service.c - third_party/glib - Git at Google

 /* GLib testing framework examples and tests
  *
  * Copyright 2014 Red Hat, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, see
  * <http://www.gnu.org/licenses/>.
  */

 #include <gio/gio.h>

 static void
 active_notify_cb (GSocketService *service,
                   GParamSpec     *pspec,
                   gpointer        data)
 {
   gboolean *success = (gboolean *)data;

   if (g_socket_service_is_active (service))
     *success = TRUE;
 }

 static void
 connected_cb (GObject      *client,
               GAsyncResult *result,
               gpointer      user_data)
 {
   GSocketService *service = G_SOCKET_SERVICE (user_data);
   GSocketConnection *conn;
   GError *error = NULL;

   g_assert_true (g_socket_service_is_active (service));

   conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (client), result, &error);
   g_assert_no_error (error);
   g_object_unref (conn);

   g_socket_service_stop (service);
   g_assert_false (g_socket_service_is_active (service));
 }

 static void
 test_start_stop (void)
 {
   gboolean success = FALSE;
   GInetAddress *iaddr;
   GSocketAddress *saddr, *listening_addr;
   GSocketService *service;
   GError *error = NULL;
   GSocketClient *client;

   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
   saddr = g_inet_socket_address_new (iaddr, 0);
   g_object_unref (iaddr);

   /* instanciate with g_object_new so we can pass active = false */
   service = g_object_new (G_TYPE_SOCKET_SERVICE, "active", FALSE, NULL);
   g_assert_false (g_socket_service_is_active (service));

   g_signal_connect (service, "notify::active", G_CALLBACK (active_notify_cb), &success);

   g_socket_listener_add_address (G_SOCKET_LISTENER (service),
                                  saddr,
                                  G_SOCKET_TYPE_STREAM,
                                  G_SOCKET_PROTOCOL_TCP,
                                  NULL,
                                  &listening_addr,
                                  &error);
   g_assert_no_error (error);
   g_object_unref (saddr);

   client = g_socket_client_new ();
   g_socket_client_connect_async (client,
                                  G_SOCKET_CONNECTABLE (listening_addr),
                                  NULL,
                                  connected_cb, service);
   g_object_unref (client);
   g_object_unref (listening_addr);

   g_socket_service_start (service);
   g_assert_true (g_socket_service_is_active (service));

   do
     g_main_context_iteration (NULL, TRUE);
   while (!success);

   g_object_unref (service);
 }

 GMutex mutex_712570;
 GCond cond_712570;
 volatile gboolean finalized;

 GType test_threaded_socket_service_get_type (void);
 typedef GThreadedSocketService TestThreadedSocketService;
 typedef GThreadedSocketServiceClass TestThreadedSocketServiceClass;

 G_DEFINE_TYPE (TestThreadedSocketService, test_threaded_socket_service, G_TYPE_THREADED_SOCKET_SERVICE)

 static void
 test_threaded_socket_service_init (TestThreadedSocketService *service)
 {
 }

 static void
 test_threaded_socket_service_finalize (GObject *object)
 {
   G_OBJECT_CLASS (test_threaded_socket_service_parent_class)->finalize (object);

   /* Signal the main thread that finalization completed successfully
    * rather than hanging.
    */
   finalized = TRUE;
   g_cond_signal (&cond_712570);
   g_mutex_unlock (&mutex_712570);
 }

 static void
 test_threaded_socket_service_class_init (TestThreadedSocketServiceClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);

   object_class->finalize = test_threaded_socket_service_finalize;
 }

 static gboolean
 connection_cb (GThreadedSocketService *service,
                GSocketConnection      *connection,
                GObject                *source_object,
                gpointer                user_data)
 {
   /* Block until the main thread has dropped its ref to @service, so that we
    * will drop the final ref from this thread.
    */
   g_mutex_lock (&mutex_712570);

   /* The service should now have 1 ref owned by the current "run"
    * signal emission, and another added by GThreadedSocketService for
    * this thread. Both will be dropped after we return.
    */
   g_assert_cmpint (G_OBJECT (service)->ref_count, ==, 2);

   return FALSE;
 }

 static void
 client_connected_cb (GObject      *client,
                      GAsyncResult *result,
                      gpointer      user_data)
 {
   GMainLoop *loop = user_data;
   GSocketConnection *conn;
   GError *error = NULL;

   conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (client), result, &error);
   g_assert_no_error (error);

   g_object_unref (conn);
   g_main_loop_quit (loop);
 }

 static void
 test_threaded_712570 (void)
 {
   GSocketService *service;
   GSocketAddress *addr, *listening_addr;
   GMainLoop *loop;
   GSocketClient *client;
   GError *error = NULL;

   g_test_bug ("712570");

   g_mutex_lock (&mutex_712570);

   service = g_object_new (test_threaded_socket_service_get_type (), NULL);

   addr = g_inet_socket_address_new_from_string ("127.0.0.1", 0);
   g_socket_listener_add_address (G_SOCKET_LISTENER (service),
                                  addr,
                                  G_SOCKET_TYPE_STREAM,
                                  G_SOCKET_PROTOCOL_TCP,
                                  NULL,
                                  &listening_addr,
                                  &error);
   g_assert_no_error (error);
   g_object_unref (addr);

   g_signal_connect (service, "run", G_CALLBACK (connection_cb), NULL);

   loop = g_main_loop_new (NULL, FALSE);

   client = g_socket_client_new ();
   g_socket_client_connect_async (client,
                                  G_SOCKET_CONNECTABLE (listening_addr),
                                  NULL,
                                  client_connected_cb, loop);
   g_object_unref (client);
   g_object_unref (listening_addr);

   g_main_loop_run (loop);
   g_main_loop_unref (loop);

   /* Stop the service and then wait for it to asynchronously cancel
    * its outstanding accept() call (and drop the associated ref).
    * At least one main context iteration is required in some circumstances
    * to ensure that the cancellation actually happens.
    */
   g_socket_service_stop (G_SOCKET_SERVICE (service));
   g_assert_false (g_socket_service_is_active (G_SOCKET_SERVICE (service)));

   do
     g_main_context_iteration (NULL, TRUE);
   while (G_OBJECT (service)->ref_count > 3);

   /* Drop our ref, then unlock the mutex and wait for the service to be
    * finalized. (Without the fix for 712570 it would hang forever here.)
    */
   g_object_unref (service);

   while (!finalized)
     g_cond_wait (&cond_712570, &mutex_712570);
   g_mutex_unlock (&mutex_712570);
 }

 int
 main (int   argc,
       char *argv[])
 {
   g_test_init (&argc, &argv, NULL);

   g_test_bug_base ("http://bugzilla.gnome.org/");

   g_test_add_func ("/socket-service/start-stop", test_start_stop);
   g_test_add_func ("/socket-service/threaded/712570", test_threaded_712570);

   return g_test_run();
 }
	/* GLib testing framework examples and tests
	*
	* Copyright 2014 Red Hat, Inc.
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, see
	* <http://www.gnu.org/licenses/>.
	*/

	#include <gio/gio.h>

	static void
	active_notify_cb (GSocketService *service,
	GParamSpec *pspec,
	gpointer data)
	{
	gboolean success = (gboolean )data;

	if (g_socket_service_is_active (service))
	*success = TRUE;
	}

	static void
	connected_cb (GObject *client,
	GAsyncResult *result,
	gpointer user_data)
	{
	GSocketService *service = G_SOCKET_SERVICE (user_data);
	GSocketConnection *conn;
	GError *error = NULL;

	g_assert_true (g_socket_service_is_active (service));

	conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (client), result, &error);
	g_assert_no_error (error);
	g_object_unref (conn);

	g_socket_service_stop (service);
	g_assert_false (g_socket_service_is_active (service));
	}

	static void
	test_start_stop (void)
	{
	gboolean success = FALSE;
	GInetAddress *iaddr;
	GSocketAddress saddr, listening_addr;
	GSocketService *service;
	GError *error = NULL;
	GSocketClient *client;

	iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
	saddr = g_inet_socket_address_new (iaddr, 0);
	g_object_unref (iaddr);

	/* instanciate with g_object_new so we can pass active = false */
	service = g_object_new (G_TYPE_SOCKET_SERVICE, "active", FALSE, NULL);
	g_assert_false (g_socket_service_is_active (service));

	g_signal_connect (service, "notify::active", G_CALLBACK (active_notify_cb), &success);

	g_socket_listener_add_address (G_SOCKET_LISTENER (service),
	saddr,
	G_SOCKET_TYPE_STREAM,
	G_SOCKET_PROTOCOL_TCP,
	NULL,
	&listening_addr,
	&error);
	g_assert_no_error (error);
	g_object_unref (saddr);

	client = g_socket_client_new ();
	g_socket_client_connect_async (client,
	G_SOCKET_CONNECTABLE (listening_addr),
	NULL,
	connected_cb, service);
	g_object_unref (client);
	g_object_unref (listening_addr);

	g_socket_service_start (service);
	g_assert_true (g_socket_service_is_active (service));

	do
	g_main_context_iteration (NULL, TRUE);
	while (!success);

	g_object_unref (service);
	}

	GMutex mutex_712570;
	GCond cond_712570;
	volatile gboolean finalized;

	GType test_threaded_socket_service_get_type (void);
	typedef GThreadedSocketService TestThreadedSocketService;
	typedef GThreadedSocketServiceClass TestThreadedSocketServiceClass;

	G_DEFINE_TYPE (TestThreadedSocketService, test_threaded_socket_service, G_TYPE_THREADED_SOCKET_SERVICE)

	static void
	test_threaded_socket_service_init (TestThreadedSocketService *service)
	{
	}

	static void
	test_threaded_socket_service_finalize (GObject *object)
	{
	G_OBJECT_CLASS (test_threaded_socket_service_parent_class)->finalize (object);

	/* Signal the main thread that finalization completed successfully
	* rather than hanging.
	*/
	finalized = TRUE;
	g_cond_signal (&cond_712570);
	g_mutex_unlock (&mutex_712570);
	}

	static void
	test_threaded_socket_service_class_init (TestThreadedSocketServiceClass *klass)
	{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	object_class->finalize = test_threaded_socket_service_finalize;
	}

	static gboolean
	connection_cb (GThreadedSocketService *service,
	GSocketConnection *connection,
	GObject *source_object,
	gpointer user_data)
	{
	/* Block until the main thread has dropped its ref to @service, so that we
	* will drop the final ref from this thread.
	*/
	g_mutex_lock (&mutex_712570);

	/* The service should now have 1 ref owned by the current "run"
	* signal emission, and another added by GThreadedSocketService for
	* this thread. Both will be dropped after we return.
	*/
	g_assert_cmpint (G_OBJECT (service)->ref_count, ==, 2);

	return FALSE;
	}

	static void
	client_connected_cb (GObject *client,
	GAsyncResult *result,
	gpointer user_data)
	{
	GMainLoop *loop = user_data;
	GSocketConnection *conn;
	GError *error = NULL;

	conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (client), result, &error);
	g_assert_no_error (error);

	g_object_unref (conn);
	g_main_loop_quit (loop);
	}

	static void
	test_threaded_712570 (void)
	{
	GSocketService *service;
	GSocketAddress addr, listening_addr;
	GMainLoop *loop;
	GSocketClient *client;
	GError *error = NULL;

	g_test_bug ("712570");

	g_mutex_lock (&mutex_712570);

	service = g_object_new (test_threaded_socket_service_get_type (), NULL);

	addr = g_inet_socket_address_new_from_string ("127.0.0.1", 0);
	g_socket_listener_add_address (G_SOCKET_LISTENER (service),
	addr,
	G_SOCKET_TYPE_STREAM,
	G_SOCKET_PROTOCOL_TCP,
	NULL,
	&listening_addr,
	&error);
	g_assert_no_error (error);
	g_object_unref (addr);

	g_signal_connect (service, "run", G_CALLBACK (connection_cb), NULL);

	loop = g_main_loop_new (NULL, FALSE);

	client = g_socket_client_new ();
	g_socket_client_connect_async (client,
	G_SOCKET_CONNECTABLE (listening_addr),
	NULL,
	client_connected_cb, loop);
	g_object_unref (client);
	g_object_unref (listening_addr);

	g_main_loop_run (loop);
	g_main_loop_unref (loop);

	/* Stop the service and then wait for it to asynchronously cancel
	* its outstanding accept() call (and drop the associated ref).
	* At least one main context iteration is required in some circumstances
	* to ensure that the cancellation actually happens.
	*/
	g_socket_service_stop (G_SOCKET_SERVICE (service));
	g_assert_false (g_socket_service_is_active (G_SOCKET_SERVICE (service)));

	do
	g_main_context_iteration (NULL, TRUE);
	while (G_OBJECT (service)->ref_count > 3);

	/* Drop our ref, then unlock the mutex and wait for the service to be
	* finalized. (Without the fix for 712570 it would hang forever here.)
	*/
	g_object_unref (service);

	while (!finalized)
	g_cond_wait (&cond_712570, &mutex_712570);
	g_mutex_unlock (&mutex_712570);
	}

	int
	main (int argc,
	char *argv[])
	{
	g_test_init (&argc, &argv, NULL);

	g_test_bug_base ("http://bugzilla.gnome.org/");

	g_test_add_func ("/socket-service/start-stop", test_start_stop);
	g_test_add_func ("/socket-service/threaded/712570", test_threaded_712570);

	return g_test_run();
	}