GNOME.org
 

[glib] gio: add a simple gpoll performance test for W32

commit 425a9f5864f69f804f11279b558ff925d421b546
Author: Руслан Ижбулатов <lrn1986 gmail com>
Date:   Sat Jul 29 07:40:35 2017 +0000

    gio: add a simple gpoll performance test for W32
    
    It just creates a number of socket pairs, then triggers read-ready status on these pairs in different 
patterns (none, one, half, all) and checks how much time it takes to g_poll() those. Also sometimes posts a 
Windows message and polls for its arrival.
    The g_main_context_new() is necessary to initialize g_poll() debugging on W32.
    
    Measures minimal and maximal time it takes to g_poll(), as well as the average, over 1000 runs.
    Collects the time values into 25 non-linear buckets between 0ns and 1000ns, and displays them at the 
conclusion of each subtest.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=785468

 glib/tests/Makefile.am |    4 +
 glib/tests/gpoll.c     |  624 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 628 insertions(+), 0 deletions(-)
---
diff --git a/glib/tests/Makefile.am b/glib/tests/Makefile.am
index 1adc50d..b3983d3 100644
--- a/glib/tests/Makefile.am
+++ b/glib/tests/Makefile.am
@@ -224,6 +224,10 @@ test_programs += \
        $(NULL)
 endif
 
+if OS_WIN32
+test_programs += gpoll
+endif
+
 # -----------------------------------------------------------------------------
 
 if HAVE_EVENTFD
diff --git a/glib/tests/gpoll.c b/glib/tests/gpoll.c
new file mode 100644
index 0000000..58656d3
--- /dev/null
+++ b/glib/tests/gpoll.c
@@ -0,0 +1,624 @@
+/* Unit test for W32 version of g_poll()
+ *
+ * Copyright © 2017 Руслан Ижбулатов <lrn1986 gmail com>
+ *
+ * This 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 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 <glib.h>
+#include <Winsock2.h>
+
+#define NUM_POLLEES 63
+#define NUM_POLLFDS 64
+
+#define ASYNC_CONNECT_OK(r) (r == 0 || (r < 0 && GetLastError () == WSAEWOULDBLOCK))
+
+#define REPEAT 1000
+
+static void
+init_networking (void)
+{
+  WSADATA wsadata;
+
+  if (WSAStartup (MAKEWORD (2, 0), &wsadata) != 0)
+    g_error ("Windows Sockets could not be initialized");
+}
+
+static void
+prepare_fds (SOCKET  sockets[],
+             GPollFD fds[],
+             int     num_pollees)
+{
+  gint i;
+
+  for (i = 0; i < num_pollees; i++)
+    {
+      fds[i].fd = (gintptr) WSACreateEvent ();
+      g_assert (WSAEventSelect (sockets[i], (HANDLE) fds[i].fd, FD_READ | FD_CLOSE) == 0);
+    }
+}
+
+static void
+reset_fds (GPollFD fds[],
+           int     num_pollees)
+{
+  gint i;
+
+  for (i = 0; i < num_pollees; i++)
+    {
+      WSAResetEvent ((HANDLE) fds[i].fd);
+      fds[i].events =  G_IO_IN | G_IO_OUT | G_IO_ERR;
+      fds[i].revents = 0;
+    }
+}
+
+static void
+reset_fds_msg (GPollFD fds[],
+               int     num_pollfds)
+{
+  fds[num_pollfds - 1].fd = G_WIN32_MSG_HANDLE;
+  fds[num_pollfds - 1].events = G_IO_IN;
+  fds[num_pollfds - 1].revents = 0;
+}
+
+static void
+check_fds (SOCKET  sockets[],
+           GPollFD fds[],
+           int     num_pollees)
+{
+  gint i;
+
+  for (i = 0; i < num_pollees; i++)
+    {
+      if (fds[i].revents != 0)
+        {
+          WSANETWORKEVENTS events;
+          g_assert (WSAEnumNetworkEvents (sockets[i], 0, &events) == 0);
+
+          fds[i].revents = 0;
+          if (events.lNetworkEvents & (FD_READ | FD_ACCEPT))
+            fds[i].revents |= G_IO_IN;
+
+          if (events.lNetworkEvents & FD_WRITE)
+            fds[i].revents |= G_IO_OUT;
+          else
+            {
+              /* We have called WSAEnumNetworkEvents() above but it didn't
+               * set FD_WRITE.
+               */
+              if (events.lNetworkEvents & FD_CONNECT)
+                {
+                  if (events.iErrorCode[FD_CONNECT_BIT] == 0)
+                    fds[i].revents |= G_IO_OUT;
+                  else
+                    fds[i].revents |= (G_IO_HUP | G_IO_ERR);
+                }
+              if (fds[i].revents == 0 && (events.lNetworkEvents & (FD_CLOSE)))
+                fds[i].revents |= G_IO_HUP;
+            }
+        }
+    }
+}
+
+static void
+prepare_sockets (SOCKET  sockets[],
+                 SOCKET  opp_sockets[],
+                 GPollFD fds[],
+                 int     num_pollees)
+{
+  gint i;
+  SOCKET server;
+  struct sockaddr_in sa;
+  unsigned long ul = 1;
+  int sa_size;
+  int r;
+
+  server = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  g_assert (server != INVALID_SOCKET);
+
+  memset(&sa, 0, sizeof sa);
+
+  sa.sin_family = AF_INET;
+  sa.sin_port = 0;
+  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  sa_size = sizeof (sa);
+
+  g_assert (bind (server, (const struct sockaddr *) &sa, sa_size) == 0);
+  g_assert (getsockname (server, (struct sockaddr *) &sa, &sa_size) == 0);
+  g_assert (listen (server, 1) == 0);
+
+  for (i = 0; i < num_pollees; i++)
+    {
+      opp_sockets[i] = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
+      g_assert (opp_sockets[i] != INVALID_SOCKET);
+      g_assert (ioctlsocket (opp_sockets[i], FIONBIO, &ul) == 0);
+
+      r = connect (opp_sockets[i], (const struct sockaddr *) &sa, sizeof (sa));
+      g_assert (ASYNC_CONNECT_OK (r));
+
+      sockets[i] = accept (server, NULL, NULL);
+      g_assert (sockets[i] != INVALID_SOCKET);
+      g_assert (ioctlsocket (sockets[i], FIONBIO, &ul) == 0);
+    }
+
+  closesocket (server);
+}
+
+static void
+cleanup_sockets (SOCKET sockets[],
+                 SOCKET opp_sockets[],
+                 int    num_pollees)
+{
+  gint i;
+
+  for (i = 0; i < num_pollees; i++)
+    {
+      closesocket (sockets[i]);
+      closesocket (opp_sockets[i]);
+    }
+}
+
+static void
+bucketize (gint64 val,
+           gint   buckets[],
+           gint64 bucket_limits[],
+           gint   count)
+{
+  gint i;
+
+  if (val > bucket_limits[count - 1])
+    {
+      buckets[count - 1] += 1;
+      return;
+    }
+
+  for (i = count - 1; i > 0; i--)
+    if (val < bucket_limits[i] && val >= bucket_limits[i - 1])
+      {
+        buckets[i] += 1;
+        return;
+      }
+
+  buckets[0] += 1;
+}
+
+static void
+print_buckets (gint   buckets[],
+               gint64 bucket_limits[],
+               gint   count)
+{
+  gint i;
+
+  for (i = 0; i < count; i++)
+    if (i < count - 1)
+      g_print ("%-4lld-%4lld|", i == 0 ? 0 : bucket_limits[i - 1], bucket_limits[i] - 1);
+    else
+      g_print ("  >= %-4lld|", bucket_limits[i - 1]);
+
+  g_print ("\n");
+
+  for (i = 0; i < count; i++)
+    {
+      gint len;
+      gint padding;
+      gint j;
+      if (buckets[i] < 10)
+        len = 1;
+      else if (buckets[i] < 100)
+        len = 2;
+      else if (buckets[i] < 1000)
+        len = 3;
+      else
+        len = 4;
+      padding = 9 - len;
+      for (j = 0; j < padding / 2; j++)
+        g_print (" ");
+      if (buckets[i] != 0)
+        g_print ("%*d", len, buckets[i]);
+      else
+        g_print (" ");
+      for (j = padding / 2; j < padding; j++)
+        g_print (" ");
+      g_print (" ");
+    }
+
+  g_print ("\n\n");
+}
+
+static void
+test_gpoll (void)
+{
+  SOCKET sockets[NUM_POLLEES];
+  GPollFD fds[NUM_POLLFDS];
+  SOCKET opp_sockets[NUM_POLLEES];
+  gint i;
+  gint activatable;
+  gint64 times[REPEAT][2];
+#define BUCKET_COUNT 25
+  gint64 bucket_limits[BUCKET_COUNT] = {3, 5, 10, 15, 20, 25, 30, 35, 40, 50, 60, 70, 80, 90, 100, 120, 150, 
180, 220, 280, 350, 450, 600, 800, 1000};
+  gint   buckets[BUCKET_COUNT];
+  gint64 times_avg = 0, times_min = G_MAXINT64, times_max = 0;
+
+  prepare_sockets (sockets, opp_sockets, fds, NUM_POLLEES);
+  prepare_fds (sockets, fds, NUM_POLLEES);
+
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r;
+      gint64 diff;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      times[i][1] = g_get_monotonic_time ();
+      g_assert (r == 0);
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("\nempty poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  activatable = 0;
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r, s, v, t;
+      gint64 diff;
+      MSG msg;
+      gboolean found_app;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      s = send (opp_sockets[activatable], (const char *) &t, 1, 0);
+      g_assert (PostMessage (NULL, WM_APP, 1, 2));
+      /* This is to ensure that all sockets catch up, otherwise some might not poll active */
+      g_usleep (G_USEC_PER_SEC / 1000);
+
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 1000);
+      times[i][1] = g_get_monotonic_time ();
+
+      check_fds (sockets, fds, NUM_POLLEES);
+      v = recv (sockets[activatable], (char *) &t, 1, 0);
+      found_app = FALSE;
+      while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+        if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)
+          found_app = TRUE;
+      g_assert (s == 1);
+      g_assert (r == 2);
+      g_assert (v == 1);
+      g_assert (found_app);
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      check_fds (sockets, fds, NUM_POLLEES);
+      g_assert (r == 0);
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      activatable = (activatable + 1) % NUM_POLLEES;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("1-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, 
times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  activatable = 0;
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r, s, v, t;
+      gint64 diff;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      s = send (opp_sockets[activatable], (const char *) &t, 1, 0);
+
+      g_usleep (G_USEC_PER_SEC / 1000);
+
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 1000);
+      times[i][1] = g_get_monotonic_time ();
+
+      check_fds (sockets, fds, NUM_POLLEES);
+      v = recv (sockets[activatable], (char *) &t, 1, 0);
+      g_assert (s == 1);
+      g_assert (r == 1);
+      g_assert (v == 1);
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      check_fds (sockets, fds, NUM_POLLEES);
+      g_assert (r == 0);
+
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      activatable = (activatable + 1) % NUM_POLLEES;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("1-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r, s, v, t;
+      gint64 diff;
+      gint j;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      s = v = 0;
+
+      for (j = 0; j < NUM_POLLEES / 2; j++)
+        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
+
+      g_usleep (G_USEC_PER_SEC / 1000);
+
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 1000);
+      times[i][1] = g_get_monotonic_time ();
+      check_fds (sockets, fds, NUM_POLLEES);
+      for (j = 0; j < NUM_POLLEES / 2; j++)
+        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
+      g_assert (s == NUM_POLLEES / 2);
+      g_assert (r == NUM_POLLEES / 2);
+      g_assert (v == NUM_POLLEES / 2);
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      check_fds (sockets, fds, NUM_POLLEES);
+      g_assert (r == 0);
+
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("half-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r, s, v, t;
+      gint64 diff;
+      gint j;
+      MSG msg;
+      gboolean found_app;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      s = v = 0;
+
+      for (j = 0; j < NUM_POLLEES / 2; j++)
+        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
+      g_assert (PostMessage (NULL, WM_APP, 1, 2));
+
+      /* This is to ensure that all sockets catch up, otherwise some might not poll active */
+      g_usleep (G_USEC_PER_SEC / 1000);
+
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 1000);
+      times[i][1] = g_get_monotonic_time ();
+      check_fds (sockets, fds, NUM_POLLEES);
+      for (j = 0; j < NUM_POLLEES / 2; j++)
+        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
+      found_app = FALSE;
+      while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+        if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)
+          found_app = TRUE;
+      g_assert (s == NUM_POLLEES / 2);
+      g_assert (r == NUM_POLLEES / 2 + 1);
+      g_assert (v == NUM_POLLEES / 2);
+      g_assert (found_app);
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      check_fds (sockets, fds, NUM_POLLEES);
+      g_assert (r == 0);
+
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("half-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, 
times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r, s, v, t;
+      gint64 diff;
+      gint j;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      s = v = 0;
+
+      for (j = 0; j < NUM_POLLEES; j++)
+        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
+
+      g_usleep (G_USEC_PER_SEC / 1000);
+
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 1000);
+      times[i][1] = g_get_monotonic_time ();
+      check_fds (sockets, fds, NUM_POLLEES);
+      for (j = 0; j < NUM_POLLEES; j++)
+        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
+      g_assert (s == NUM_POLLEES);
+      g_assert (r == NUM_POLLEES);
+      g_assert (v == NUM_POLLEES);
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      check_fds (sockets, fds, NUM_POLLEES);
+      g_assert (r == 0);
+
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("%d-socket poll time: \n%4lldns - %4lldns, average %4lldns\n", NUM_POLLEES, times_min, times_max, 
times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  activatable = 0;
+  times_avg = 0;
+  times_min = G_MAXINT64;
+  times_max = 0;
+  memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
+
+  for (i = 0; i < REPEAT; i++)
+    {
+      gint r, s, v, t;
+      gint64 diff;
+      gint j;
+      MSG msg;
+      gboolean found_app;
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      s = v = 0;
+
+      for (j = 0; j < activatable; j++)
+        s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
+      g_assert (PostMessage (NULL, WM_APP, 1, 2));
+
+      g_usleep (G_USEC_PER_SEC / 1000);
+
+      times[i][0] = g_get_monotonic_time ();
+      r = g_poll (fds, NUM_POLLFDS, 1000);
+      times[i][1] = g_get_monotonic_time ();
+      check_fds (sockets, fds, NUM_POLLEES);
+      for (j = 0; j < activatable; j++)
+        v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
+      found_app = FALSE;
+      while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+        if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)
+          found_app = TRUE;
+      g_assert (s == activatable);
+      g_assert (r == activatable + 1);
+      g_assert (v == activatable);
+      g_assert (found_app);
+
+      reset_fds (fds, NUM_POLLEES);
+      reset_fds_msg (fds, NUM_POLLFDS);
+      r = g_poll (fds, NUM_POLLFDS, 0);
+      check_fds (sockets, fds, NUM_POLLEES);
+      g_assert (r == 0);
+
+      diff = times[i][1] - times[i][0];
+      if (times_min > diff)
+        times_min = diff;
+      if (times_max < diff)
+        times_max = diff;
+      times_avg += diff;
+      bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
+      activatable = (activatable + 1) % NUM_POLLEES;
+    }
+
+  times_avg /= NUM_POLLEES;
+  g_print ("variable socket number + msg poll time: \n%4lldns - %4lldns, average %4lldns\n", times_min, 
times_max, times_avg);
+  print_buckets (buckets, bucket_limits, BUCKET_COUNT);
+
+  cleanup_sockets (sockets, opp_sockets, NUM_POLLEES);
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+  int result;
+  GMainContext *ctx;
+
+  g_test_init (&argc, &argv, NULL);
+  init_networking ();
+  ctx = g_main_context_new ();
+
+  g_test_add_func ("/gpoll/gpoll", test_gpoll);
+
+  result = g_test_run ();
+
+  g_main_context_unref (ctx);
+
+  return result;
+}
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]