tests/test-io-stream-pollable.c

   1 /*
   2  * This file is part of the Nice GLib ICE library.
   3  *
   4  * (C) 2014 Collabora Ltd.
   5  *  Contact: Philip Withnall
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is the Nice GLib ICE library.
  18  *
  19  * The Initial Developers of the Original Code are Collabora Ltd and Nokia
  20  * Corporation. All Rights Reserved.
  21  *
  22  * Contributors:
  23  *   Philip Withnall, Collabora Ltd.
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of the
  26  * the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
  27  * case the provisions of LGPL are applicable instead of those above. If you
  28  * wish to allow use of your version of this file only under the terms of the
  29  * LGPL and not to allow others to use your version of this file under the
  30  * MPL, indicate your decision by deleting the provisions above and replace
  31  * them with the notice and other provisions required by the LGPL. If you do
  32  * not delete the provisions above, a recipient may use your version of this
  33  * file under either the MPL or the LGPL.
  34  */
  35 #ifdef HAVE_CONFIG_H
  36 # include <config.h>
  37 #endif
  38
  39 #include "agent.h"
  40 #include "test-io-stream-common.h"
  41
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #ifndef G_OS_WIN32
  45 #include <unistd.h>
  46 #endif
  47
  48 typedef struct {
  49   GMainLoop *read_loop;  /* unowned */
  50
  51   gsize recv_count;
  52   gsize *other_recv_count;
  53
  54   gsize send_count;
  55   gsize *other_send_count;
  56 } ThreadData;
  57
  58 static gboolean
  59 read_stream_cb (GObject *pollable_stream, gpointer _user_data)
  60 {
  61   TestIOStreamThreadData *data = _user_data;
  62   ThreadData *user_data = data->user_data;
  63   gchar expected_data[MESSAGE_SIZE];
  64   GError *error = NULL;
  65   guint8 buf[MESSAGE_SIZE];
  66   gssize len;
  67
  68   /* Try to receive some data. */
  69   len = g_pollable_input_stream_read_nonblocking (
  70       G_POLLABLE_INPUT_STREAM (pollable_stream), buf, sizeof (buf), NULL,
  71       &error);
  72
  73   if (len == -1) {
  74     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
  75     g_error_free (error);
  76     return TRUE;
  77   }
  78
  79   g_assert_cmpint (len, ==, MESSAGE_SIZE);
  80
  81   memset (expected_data, user_data->recv_count + '1', sizeof (expected_data));
  82   g_assert_cmpmem (buf, sizeof (expected_data), expected_data, sizeof (expected_data));
  83
  84   user_data->recv_count++;
  85
  86   if (user_data->recv_count == 10) {
  87     g_main_loop_quit (user_data->read_loop);
  88     return FALSE;
  89   }
  90
  91   return TRUE;
  92 }
  93
  94 static void
  95 read_thread_cb (GInputStream *input_stream, TestIOStreamThreadData *data)
  96 {
  97   GMainContext *main_context;
  98   GMainLoop *main_loop;
  99   GSource *stream_source;
 100   ThreadData *user_data = data->user_data;
 101
 102   main_context = g_main_context_new ();
 103   main_loop = g_main_loop_new (main_context, FALSE);
 104   g_main_context_push_thread_default (main_context);
 105
 106   stream_source =
 107       g_pollable_input_stream_create_source (
 108           G_POLLABLE_INPUT_STREAM (input_stream), NULL);
 109
 110   g_source_set_callback (stream_source, G_SOURCE_FUNC (read_stream_cb),
 111       data, NULL);
 112   g_source_attach (stream_source, main_context);
 113   g_source_unref (stream_source);
 114
 115   /* Run the main loop. */
 116   user_data->read_loop = main_loop;
 117   g_main_loop_run (main_loop);
 118
 119   g_main_context_pop_thread_default (main_context);
 120   g_main_loop_unref (main_loop);
 121   g_main_context_unref (main_context);
 122
 123   check_for_termination (data, &user_data->recv_count,
 124       user_data->other_recv_count, &user_data->send_count, 10);
 125 }
 126
 127 static void
 128 write_thread_cb (GOutputStream *output_stream, TestIOStreamThreadData *data)
 129 {
 130   ThreadData *user_data = data->user_data;
 131   guint8 buf[MESSAGE_SIZE];
 132
 133   for (user_data->send_count = 0;
 134        user_data->send_count < 10;
 135        user_data->send_count++) {
 136     GError *error = NULL;
 137
 138     memset (buf, user_data->send_count + '1', MESSAGE_SIZE);
 139
 140     g_pollable_output_stream_write_nonblocking (
 141         G_POLLABLE_OUTPUT_STREAM (output_stream), buf, sizeof (buf), NULL,
 142         &error);
 143     g_assert_no_error (error);
 144   }
 145 }
 146
 147 int main (void)
 148 {
 149   ThreadData *l_data, *r_data;
 150
 151   const TestIOStreamCallbacks callbacks = {
 152     read_thread_cb,
 153     write_thread_cb,
 154     NULL,
 155     NULL,
 156   };
 157
 158 #ifdef G_OS_WIN32
 159   WSADATA w;
 160   WSAStartup (0x0202, &w);
 161 #endif
 162
 163   l_data = g_malloc0 (sizeof (ThreadData));
 164   r_data = g_malloc0 (sizeof (ThreadData));
 165
 166   l_data->recv_count = 0;
 167   l_data->send_count = 0;
 168   l_data->other_recv_count = &r_data->recv_count;
 169   l_data->other_send_count = &r_data->send_count;
 170
 171   r_data->recv_count = 0;
 172   r_data->send_count = 0;
 173   r_data->other_recv_count = &l_data->recv_count;
 174   r_data->other_send_count = &l_data->send_count;
 175
 176   run_io_stream_test (30, TRUE, &callbacks, l_data, NULL, r_data, NULL);
 177
 178   g_free (r_data);
 179   g_free (l_data);
 180
 181 #ifdef G_OS_WIN32
 182   WSACleanup ();
 183 #endif
 184   return 0;
 185 }