gio/tests/buffered-input-stream.c

   1 /* GLib testing framework examples and tests
   2  * Copyright (C) 2008 Red Hat, Inc.
   3  * Authors: Matthias Clasen <mclasen@redhat.com>
   4  *
   5  * SPDX-License-Identifier: LicenseRef-old-glib-tests
   6  *
   7  * This work is provided "as is"; redistribution and modification
   8  * in whole or in part, in any medium, physical or electronic is
   9  * permitted without restriction.
  10  *
  11  * This work is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14  *
  15  * In no event shall the authors or contributors be liable for any
  16  * direct, indirect, incidental, special, exemplary, or consequential
  17  * damages (including, but not limited to, procurement of substitute
  18  * goods or services; loss of use, data, or profits; or business
  19  * interruption) however caused and on any theory of liability, whether
  20  * in contract, strict liability, or tort (including negligence or
  21  * otherwise) arising in any way out of the use of this software, even
  22  * if advised of the possibility of such damage.
  23  */
  24
  25 #include <glib/glib.h>
  26 #include <gio/gio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 static void
  31 test_peek (void)
  32 {
  33   GInputStream *base;
  34   GInputStream *in;
  35   gssize npeek;
  36   char *buffer;
  37
  38   base = g_memory_input_stream_new_from_data ("abcdefghijk", -1, NULL);
  39   in = g_buffered_input_stream_new_sized (base, 64);
  40
  41   g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (in), 5, NULL, NULL);
  42   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 5);
  43   g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (in), -1, NULL, NULL);
  44   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, strlen ("abcdefjhijk"));
  45
  46   buffer = g_new0 (char, 64);
  47   npeek = g_buffered_input_stream_peek (G_BUFFERED_INPUT_STREAM (in), buffer, 2, 3);
  48   g_assert_cmpint (npeek, ==, 3);
  49   g_assert_cmpstr ("cde", ==, buffer);
  50   g_free (buffer);
  51
  52   buffer = g_new0 (char, 64);
  53   npeek = g_buffered_input_stream_peek (G_BUFFERED_INPUT_STREAM (in), buffer, 9, 5);
  54   g_assert_cmpint (npeek, ==, 2);
  55   g_assert_cmpstr ("jk", ==, buffer);
  56   g_free (buffer);
  57
  58   buffer = g_new0 (char, 64);
  59   npeek = g_buffered_input_stream_peek (G_BUFFERED_INPUT_STREAM (in), buffer, 75, 3);
  60   g_assert_cmpint (npeek, ==, 0);
  61   g_free (buffer);
  62
  63   g_object_unref (in);
  64   g_object_unref (base);
  65 }
  66
  67 static void
  68 test_peek_buffer (void)
  69 {
  70   GInputStream *base;
  71   GInputStream *in;
  72   gssize nfill;
  73   gsize bufsize;
  74   char *buffer;
  75
  76   base = g_memory_input_stream_new_from_data ("abcdefghijk", -1, NULL);
  77   in = g_buffered_input_stream_new (base);
  78
  79   nfill = g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (in), strlen ("abcdefghijk"), NULL, NULL);
  80   buffer = (char *) g_buffered_input_stream_peek_buffer (G_BUFFERED_INPUT_STREAM (in), &bufsize);
  81   g_assert_cmpint (nfill, ==, bufsize);
  82   g_assert (0 == strncmp ("abcdefghijk", buffer, bufsize));
  83
  84   g_object_unref (in);
  85   g_object_unref (base);
  86 }
  87
  88 static void
  89 test_set_buffer_size (void)
  90 {
  91   GInputStream *base;
  92   GInputStream *in;
  93   guint bufsize_prop;
  94   gsize size, bufsize;
  95
  96   base = g_memory_input_stream_new_from_data ("abcdefghijk", -1, NULL);
  97   in = g_buffered_input_stream_new (base);
  98   size = g_buffered_input_stream_get_buffer_size (G_BUFFERED_INPUT_STREAM (in));
  99   g_assert_cmpint (size, ==, 4096);
 100
 101   g_buffered_input_stream_set_buffer_size (G_BUFFERED_INPUT_STREAM (in), 64);
 102   size = g_buffered_input_stream_get_buffer_size (G_BUFFERED_INPUT_STREAM (in));
 103   g_assert_cmpint (size, ==, 64);
 104
 105   /* size cannot shrink below current content len */
 106   g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (in), strlen ("abcdefghijk"), NULL, NULL);
 107   g_buffered_input_stream_peek_buffer (G_BUFFERED_INPUT_STREAM (in), &bufsize);
 108   g_buffered_input_stream_set_buffer_size (G_BUFFERED_INPUT_STREAM (in), 2);
 109   size = g_buffered_input_stream_get_buffer_size (G_BUFFERED_INPUT_STREAM (in));
 110   g_assert_cmpint (size, ==, bufsize);
 111   g_object_get (in, "buffer-size", &bufsize_prop, NULL);
 112   g_assert_cmpint (bufsize_prop, ==, bufsize);
 113
 114   g_object_unref (in);
 115
 116   in = g_buffered_input_stream_new_sized (base, 64);
 117   size = g_buffered_input_stream_get_buffer_size (G_BUFFERED_INPUT_STREAM (in));
 118   g_assert_cmpint (size, ==, 64);
 119
 120   g_object_unref (in);
 121   g_object_unref (base);
 122 }
 123
 124 static void
 125 test_read_byte (void)
 126 {
 127   GInputStream *base;
 128   GInputStream *in;
 129   GError *error;
 130
 131   g_test_bug ("https://bugzilla.gnome.org/show_bug.cgi?id=562393");
 132
 133   base = g_memory_input_stream_new_from_data ("abcdefgh", -1, NULL);
 134   in = g_buffered_input_stream_new (base);
 135
 136   error = NULL;
 137   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'a');
 138   g_assert_no_error (error);
 139   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'b');
 140   g_assert_no_error (error);
 141   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'c');
 142   g_assert_no_error (error);
 143
 144   g_assert_cmpint (g_input_stream_skip (in, 3, NULL, &error), ==, 3);
 145   g_assert_no_error (error);
 146
 147   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'g');
 148   g_assert_no_error (error);
 149   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'h');
 150   g_assert_no_error (error);
 151   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, -1);
 152   g_assert_no_error (error);
 153
 154   g_assert (g_input_stream_close (in, NULL, &error));
 155   g_assert_no_error (error);
 156   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, -1);
 157   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
 158   g_error_free (error);
 159
 160   g_object_unref (in);
 161   g_object_unref (base);
 162 }
 163
 164 static void
 165 test_read (void)
 166 {
 167   GInputStream *base;
 168   GInputStream *in;
 169   gchar buffer[20];
 170   GError *error;
 171
 172   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -1, NULL);
 173   in = g_buffered_input_stream_new_sized (base, 8);
 174
 175   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 0);
 176
 177   error = NULL;
 178   g_assert_cmpint (g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (in), 8, NULL, &error), ==, 8);
 179   g_assert_no_error (error);
 180
 181   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 8);
 182
 183   memset (buffer, 0, 20);
 184   g_assert_cmpint (g_input_stream_read (in, &buffer, 16, NULL, &error), ==, 16);
 185   g_assert_cmpstr (buffer, ==, "abcdefghijklmnop");
 186   g_assert_no_error (error);
 187
 188   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 0);
 189
 190   memset (buffer, 0, 20);
 191   g_assert_cmpint (g_input_stream_read (in, &buffer, 16, NULL, &error), ==, 16);
 192   g_assert_cmpstr (buffer, ==, "qrstuvwxyzABCDEF");
 193   g_assert_no_error (error);
 194
 195   memset (buffer, 0, 20);
 196   g_assert_cmpint (g_input_stream_read (in, &buffer, 16, NULL, &error), ==, 16);
 197   g_assert_cmpstr (buffer, ==, "GHIJKLMNOPQRSTUV");
 198   g_assert_no_error (error);
 199
 200   memset (buffer, 0, 20);
 201   g_assert_cmpint (g_input_stream_read (in, &buffer, 16, NULL, &error), ==, 4);
 202   g_assert_cmpstr (buffer, ==, "WXYZ");
 203   g_assert_no_error (error);
 204
 205   memset (buffer, 0, 20);
 206   g_assert_cmpint (g_input_stream_read (in, &buffer, 16, NULL, &error), ==, 0);
 207   g_assert_no_error (error);
 208
 209   g_object_unref (in);
 210   g_object_unref (base);
 211 }
 212
 213 static void
 214 return_result_cb (GObject      *object,
 215                   GAsyncResult *result,
 216                   gpointer      user_data)
 217 {
 218   GAsyncResult **ret = user_data;
 219
 220   *ret = g_object_ref (result);
 221 }
 222
 223 static void
 224 test_read_async (void)
 225 {
 226   GInputStream *base;
 227   GInputStream *in;
 228   gchar buffer[20];
 229   GError *error;
 230   GAsyncResult *result;
 231
 232   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -1, NULL);
 233   in = g_buffered_input_stream_new_sized (base, 8);
 234
 235   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 0);
 236
 237   error = NULL;
 238   result = NULL;
 239   g_buffered_input_stream_fill_async (G_BUFFERED_INPUT_STREAM (in), 8,
 240                                       G_PRIORITY_DEFAULT, NULL,
 241                                       return_result_cb, &result);
 242   while (!result)
 243     g_main_context_iteration (NULL, TRUE);
 244   g_assert_cmpint (g_buffered_input_stream_fill_finish (G_BUFFERED_INPUT_STREAM (in), result, &error), ==, 8);
 245   g_assert_no_error (error);
 246   g_clear_object (&result);
 247
 248   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 8);
 249
 250   memset (buffer, 0, 20);
 251   g_input_stream_read_async (in, &buffer, 16, G_PRIORITY_DEFAULT,
 252                              NULL, return_result_cb, &result);
 253   while (!result)
 254     g_main_context_iteration (NULL, TRUE);
 255   g_assert_cmpint (g_input_stream_read_finish (in, result, &error), ==, 16);
 256   g_assert_cmpstr (buffer, ==, "abcdefghijklmnop");
 257   g_assert_no_error (error);
 258   g_clear_object (&result);
 259
 260   g_assert_cmpint (g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (in)), ==, 0);
 261
 262   memset (buffer, 0, 20);
 263   g_input_stream_read_async (in, &buffer, 16, G_PRIORITY_DEFAULT,
 264                              NULL, return_result_cb, &result);
 265   while (!result)
 266     g_main_context_iteration (NULL, TRUE);
 267   g_assert_cmpint (g_input_stream_read_finish (in, result, &error), ==, 16);
 268   g_assert_cmpstr (buffer, ==, "qrstuvwxyzABCDEF");
 269   g_assert_no_error (error);
 270   g_clear_object (&result);
 271
 272   memset (buffer, 0, 20);
 273   g_input_stream_read_async (in, &buffer, 16, G_PRIORITY_DEFAULT,
 274                              NULL, return_result_cb, &result);
 275   while (!result)
 276     g_main_context_iteration (NULL, TRUE);
 277   g_assert_cmpint (g_input_stream_read_finish (in, result, &error), ==, 16);
 278   g_assert_cmpstr (buffer, ==, "GHIJKLMNOPQRSTUV");
 279   g_assert_no_error (error);
 280   g_clear_object (&result);
 281
 282   memset (buffer, 0, 20);
 283   g_input_stream_read_async (in, &buffer, 16, G_PRIORITY_DEFAULT,
 284                              NULL, return_result_cb, &result);
 285   while (!result)
 286     g_main_context_iteration (NULL, TRUE);
 287   g_assert_cmpint (g_input_stream_read_finish (in, result, &error), ==, 4);
 288   g_assert_cmpstr (buffer, ==, "WXYZ");
 289   g_assert_no_error (error);
 290   g_clear_object (&result);
 291
 292   memset (buffer, 0, 20);
 293   g_input_stream_read_async (in, &buffer, 16, G_PRIORITY_DEFAULT,
 294                              NULL, return_result_cb, &result);
 295   while (!result)
 296     g_main_context_iteration (NULL, TRUE);
 297   g_assert_cmpint (g_input_stream_read_finish (in, result, &error), ==, 0);
 298   g_assert_no_error (error);
 299   g_clear_object (&result);
 300
 301   g_object_unref (in);
 302   g_object_unref (base);
 303 }
 304
 305 static void
 306 test_skip (void)
 307 {
 308   GInputStream *base;
 309   GInputStream *in;
 310   GError *error;
 311
 312   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ", -1, NULL);
 313   in = g_buffered_input_stream_new_sized (base, 5);
 314
 315   error = NULL;
 316   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'a');
 317   g_assert_no_error (error);
 318   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'b');
 319   g_assert_no_error (error);
 320   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'c');
 321   g_assert_no_error (error);
 322
 323   g_assert_cmpint (g_input_stream_skip (in, 7, NULL, &error), ==, 7);
 324   g_assert_no_error (error);
 325   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'k');
 326   g_assert_no_error (error);
 327
 328   g_assert_cmpint (g_input_stream_skip (in, 10, NULL, &error), ==, 10);
 329   g_assert_no_error (error);
 330   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'v');
 331   g_assert_no_error (error);
 332
 333   g_assert_cmpint (g_input_stream_skip (in, 20, NULL, &error), ==, 20);
 334   g_assert_no_error (error);
 335   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'Q');
 336   g_assert_no_error (error);
 337
 338   g_assert_cmpint (g_input_stream_skip (in, 10, NULL, &error), ==, 8);
 339   g_assert_no_error (error);
 340   g_assert_cmpint (g_input_stream_skip (in, 10, NULL, &error), ==, 0);
 341   g_assert_no_error (error);
 342
 343   g_object_unref (in);
 344   g_object_unref (base);
 345 }
 346
 347 static void
 348 test_skip_async (void)
 349 {
 350   GInputStream *base;
 351   GInputStream *in;
 352   GError *error;
 353   GAsyncResult *result;
 354
 355   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ", -1, NULL);
 356   in = g_buffered_input_stream_new_sized (base, 5);
 357
 358   error = NULL;
 359   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'a');
 360   g_assert_no_error (error);
 361   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'b');
 362   g_assert_no_error (error);
 363   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'c');
 364   g_assert_no_error (error);
 365
 366   result = NULL;
 367   g_input_stream_skip_async (in, 7, G_PRIORITY_DEFAULT,
 368                              NULL, return_result_cb, &result);
 369   while (!result)
 370     g_main_context_iteration (NULL, TRUE);
 371   g_assert_cmpint (g_input_stream_skip_finish (in, result, &error), ==, 7);
 372   g_assert_no_error (error);
 373   g_clear_object (&result);
 374   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'k');
 375   g_assert_no_error (error);
 376
 377   g_input_stream_skip_async (in, 10, G_PRIORITY_DEFAULT,
 378                              NULL, return_result_cb, &result);
 379   while (!result)
 380     g_main_context_iteration (NULL, TRUE);
 381   g_assert_cmpint (g_input_stream_skip_finish (in, result, &error), ==, 10);
 382   g_assert_no_error (error);
 383   g_clear_object (&result);
 384   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'v');
 385   g_assert_no_error (error);
 386
 387   g_input_stream_skip_async (in, 20, G_PRIORITY_DEFAULT,
 388                              NULL, return_result_cb, &result);
 389   while (!result)
 390     g_main_context_iteration (NULL, TRUE);
 391   g_assert_cmpint (g_input_stream_skip_finish (in, result, &error), ==, 20);
 392   g_assert_no_error (error);
 393   g_clear_object (&result);
 394   g_assert_cmpint (g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error), ==, 'Q');
 395   g_assert_no_error (error);
 396
 397   g_input_stream_skip_async (in, 10, G_PRIORITY_DEFAULT,
 398                              NULL, return_result_cb, &result);
 399   while (!result)
 400     g_main_context_iteration (NULL, TRUE);
 401   g_assert_cmpint (g_input_stream_skip_finish (in, result, &error), ==, 8);
 402   g_clear_object (&result);
 403   g_assert_no_error (error);
 404
 405   g_input_stream_skip_async (in, 10, G_PRIORITY_DEFAULT,
 406                              NULL, return_result_cb, &result);
 407   while (!result)
 408     g_main_context_iteration (NULL, TRUE);
 409   g_assert_cmpint (g_input_stream_skip_finish (in, result, &error), ==, 0);
 410   g_clear_object (&result);
 411   g_assert_no_error (error);
 412
 413   g_object_unref (in);
 414   g_object_unref (base);
 415 }
 416
 417 static void
 418 test_close (void)
 419 {
 420   GInputStream *base;
 421   GInputStream *in;
 422   GError *error;
 423
 424   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ", -1, NULL);
 425   in = g_buffered_input_stream_new (base);
 426
 427   g_assert (g_filter_input_stream_get_close_base_stream (G_FILTER_INPUT_STREAM (in)));
 428
 429   error = NULL;
 430   g_assert (g_input_stream_close (in, NULL, &error));
 431   g_assert_no_error (error);
 432   g_assert (g_input_stream_is_closed (base));
 433
 434   g_object_unref (in);
 435   g_object_unref (base);
 436
 437   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ", -1, NULL);
 438   in = g_buffered_input_stream_new (base);
 439
 440   g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (in), FALSE);
 441
 442   error = NULL;
 443   g_assert (g_input_stream_close (in, NULL, &error));
 444   g_assert_no_error (error);
 445   g_assert (!g_input_stream_is_closed (base));
 446
 447   g_object_unref (in);
 448   g_object_unref (base);
 449 }
 450
 451 static void
 452 test_seek (void)
 453 {
 454   GInputStream *base;
 455   GInputStream *in;
 456   GError *error;
 457   gint byte;
 458   gboolean ret;
 459
 460   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ", -1, NULL);
 461   in = g_buffered_input_stream_new_sized (base, 4);
 462   error = NULL;
 463
 464   /* Seek by read */
 465   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 0);
 466   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 467   g_assert_no_error (error);
 468   g_assert_cmpint (byte, ==, 'a');
 469   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 1);
 470
 471   /* Seek forward (in buffer) */
 472   ret = g_seekable_seek (G_SEEKABLE (in), 1, G_SEEK_CUR, NULL, &error);
 473   g_assert_no_error (error);
 474   g_assert (ret);
 475   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 2);
 476   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 477   g_assert_no_error (error);
 478   g_assert_cmpint (byte, ==, 'c');
 479   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 3);
 480
 481   /* Seek backward (in buffer) */
 482   ret = g_seekable_seek (G_SEEKABLE (in), -2, G_SEEK_CUR, NULL, &error);
 483   g_assert_no_error (error);
 484   g_assert (ret);
 485   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 1);
 486   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 487   g_assert_no_error (error);
 488   g_assert_cmpint (byte, ==, 'b');
 489   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 2);
 490
 491   /* Seek forward (outside buffer) */
 492   ret = g_seekable_seek (G_SEEKABLE (in), 6, G_SEEK_CUR, NULL, &error);
 493   g_assert_no_error (error);
 494   g_assert (ret);
 495   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 8);
 496   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 497   g_assert_no_error (error);
 498   g_assert_cmpint (byte, ==, 'i');
 499   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 9);
 500
 501   /* Seek backward (outside buffer) */
 502   ret = g_seekable_seek (G_SEEKABLE (in), -6, G_SEEK_CUR, NULL, &error);
 503   g_assert_no_error (error);
 504   g_assert (ret);
 505   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 3);
 506   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 507   g_assert_no_error (error);
 508   g_assert_cmpint (byte, ==, 'd');
 509   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 4);
 510
 511   /* Seek from beginning */
 512   ret = g_seekable_seek (G_SEEKABLE (in), 8, G_SEEK_SET, NULL, &error);
 513   g_assert_no_error (error);
 514   g_assert (ret);
 515   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 8);
 516   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 517   g_assert_no_error (error);
 518   g_assert_cmpint (byte, ==, 'i');
 519   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 9);
 520
 521   /* Seek from end */
 522   ret = g_seekable_seek (G_SEEKABLE (in), -1, G_SEEK_END, NULL, &error);
 523   g_assert_no_error (error);
 524   g_assert (ret);
 525   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 50);
 526   byte = g_buffered_input_stream_read_byte (G_BUFFERED_INPUT_STREAM (in), NULL, &error);
 527   g_assert_no_error (error);
 528   g_assert_cmpint (byte, ==, 'Z');
 529   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (in)), ==, 51);
 530
 531   /* Cleanup */
 532   g_object_unref (in);
 533   g_object_unref (base);
 534 }
 535
 536 int
 537 main (int   argc,
 538       char *argv[])
 539 {
 540   g_test_init (&argc, &argv, NULL);
 541
 542   g_test_add_func ("/buffered-input-stream/peek", test_peek);
 543   g_test_add_func ("/buffered-input-stream/peek-buffer", test_peek_buffer);
 544   g_test_add_func ("/buffered-input-stream/set-buffer-size", test_set_buffer_size);
 545   g_test_add_func ("/buffered-input-stream/read-byte", test_read_byte);
 546   g_test_add_func ("/buffered-input-stream/read", test_read);
 547   g_test_add_func ("/buffered-input-stream/read-async", test_read_async);
 548   g_test_add_func ("/buffered-input-stream/skip", test_skip);
 549   g_test_add_func ("/buffered-input-stream/skip-async", test_skip_async);
 550   g_test_add_func ("/buffered-input-stream/seek", test_seek);
 551   g_test_add_func ("/filter-input-stream/close", test_close);
 552
 553   return g_test_run();
 554 }