gio/tests/converter-stream.c

   1 /* GLib testing framework examples and tests
   2  * Copyright (C) 2009 Red Hat, Inc.
   3  * Authors: Alexander Larsson <alexl@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 #define G_TYPE_EXPANDER_CONVERTER         (g_expander_converter_get_type ())
  31 #define G_EXPANDER_CONVERTER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_EXPANDER_CONVERTER, GExpanderConverter))
  32 #define G_EXPANDER_CONVERTER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_EXPANDER_CONVERTER, GExpanderConverterClass))
  33 #define G_IS_EXPANDER_CONVERTER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_EXPANDER_CONVERTER))
  34 #define G_IS_EXPANDER_CONVERTER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_EXPANDER_CONVERTER))
  35 #define G_EXPANDER_CONVERTER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_EXPANDER_CONVERTER, GExpanderConverterClass))
  36
  37 typedef struct _GExpanderConverter       GExpanderConverter;
  38 typedef struct _GExpanderConverterClass  GExpanderConverterClass;
  39
  40 struct _GExpanderConverterClass
  41 {
  42   GObjectClass parent_class;
  43 };
  44
  45 GType       g_expander_converter_get_type (void) G_GNUC_CONST;
  46 GConverter *g_expander_converter_new      (void);
  47
  48
  49
  50 static void g_expander_converter_iface_init          (GConverterIface *iface);
  51
  52 struct _GExpanderConverter
  53 {
  54   GObject parent_instance;
  55 };
  56
  57 G_DEFINE_TYPE_WITH_CODE (GExpanderConverter, g_expander_converter, G_TYPE_OBJECT,
  58                          G_IMPLEMENT_INTERFACE (G_TYPE_CONVERTER,
  59                                                 g_expander_converter_iface_init))
  60
  61 static void
  62 g_expander_converter_class_init (GExpanderConverterClass *klass)
  63 {
  64 }
  65
  66 static void
  67 g_expander_converter_init (GExpanderConverter *local)
  68 {
  69 }
  70
  71 GConverter *
  72 g_expander_converter_new (void)
  73 {
  74   GConverter *conv;
  75
  76   conv = g_object_new (G_TYPE_EXPANDER_CONVERTER, NULL);
  77
  78   return conv;
  79 }
  80
  81 static void
  82 g_expander_converter_reset (GConverter *converter)
  83 {
  84 }
  85
  86 static GConverterResult
  87 g_expander_converter_convert (GConverter *converter,
  88                               const void *inbuf,
  89                               gsize       inbuf_size,
  90                               void       *outbuf,
  91                               gsize       outbuf_size,
  92                               GConverterFlags flags,
  93                               gsize      *bytes_read,
  94                               gsize      *bytes_written,
  95                               GError    **error)
  96 {
  97   const guint8 *in, *in_end;
  98   guint8 v, *out;
  99   gsize i;
 100   gsize block_size;
 101
 102   in = inbuf;
 103   out = outbuf;
 104   in_end = in + inbuf_size;
 105
 106   while (in < in_end)
 107     {
 108       v = *in;
 109
 110       if (v == 0)
 111         block_size = 10;
 112       else
 113         block_size = v * 1000;
 114
 115       if (outbuf_size < block_size)
 116         {
 117           if (*bytes_read > 0)
 118             return G_CONVERTER_CONVERTED;
 119
 120           g_set_error_literal (error, G_IO_ERROR,
 121                                G_IO_ERROR_NO_SPACE,
 122                                "No space in dest");
 123           return G_CONVERTER_ERROR;
 124         }
 125
 126       in++;
 127       *bytes_read += 1;
 128       *bytes_written += block_size;
 129       outbuf_size -= block_size;
 130       for (i = 0; i < block_size; i++)
 131         *out++ = v;
 132     }
 133
 134   if (in == in_end && (flags & G_CONVERTER_INPUT_AT_END))
 135     return G_CONVERTER_FINISHED;
 136   return G_CONVERTER_CONVERTED;
 137 }
 138
 139 static void
 140 g_expander_converter_iface_init (GConverterIface *iface)
 141 {
 142   iface->convert = g_expander_converter_convert;
 143   iface->reset = g_expander_converter_reset;
 144 }
 145
 146 #define G_TYPE_COMPRESSOR_CONVERTER         (g_compressor_converter_get_type ())
 147 #define G_COMPRESSOR_CONVERTER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_COMPRESSOR_CONVERTER, GCompressorConverter))
 148 #define G_COMPRESSOR_CONVERTER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_COMPRESSOR_CONVERTER, GCompressorConverterClass))
 149 #define G_IS_COMPRESSOR_CONVERTER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_COMPRESSOR_CONVERTER))
 150 #define G_IS_COMPRESSOR_CONVERTER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_COMPRESSOR_CONVERTER))
 151 #define G_COMPRESSOR_CONVERTER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_COMPRESSOR_CONVERTER, GCompressorConverterClass))
 152
 153 typedef struct _GCompressorConverter       GCompressorConverter;
 154 typedef struct _GCompressorConverterClass  GCompressorConverterClass;
 155
 156 struct _GCompressorConverterClass
 157 {
 158   GObjectClass parent_class;
 159 };
 160
 161 GType       g_compressor_converter_get_type (void) G_GNUC_CONST;
 162 GConverter *g_compressor_converter_new      (void);
 163
 164
 165
 166 static void g_compressor_converter_iface_init          (GConverterIface *iface);
 167
 168 struct _GCompressorConverter
 169 {
 170   GObject parent_instance;
 171 };
 172
 173 G_DEFINE_TYPE_WITH_CODE (GCompressorConverter, g_compressor_converter, G_TYPE_OBJECT,
 174                          G_IMPLEMENT_INTERFACE (G_TYPE_CONVERTER,
 175                                                 g_compressor_converter_iface_init))
 176
 177 static void
 178 g_compressor_converter_class_init (GCompressorConverterClass *klass)
 179 {
 180 }
 181
 182 static void
 183 g_compressor_converter_init (GCompressorConverter *local)
 184 {
 185 }
 186
 187 GConverter *
 188 g_compressor_converter_new (void)
 189 {
 190   GConverter *conv;
 191
 192   conv = g_object_new (G_TYPE_COMPRESSOR_CONVERTER, NULL);
 193
 194   return conv;
 195 }
 196
 197 static void
 198 g_compressor_converter_reset (GConverter *converter)
 199 {
 200 }
 201
 202 static GConverterResult
 203 g_compressor_converter_convert (GConverter *converter,
 204                                 const void *inbuf,
 205                                 gsize       inbuf_size,
 206                                 void       *outbuf,
 207                                 gsize       outbuf_size,
 208                                 GConverterFlags flags,
 209                                 gsize      *bytes_read,
 210                                 gsize      *bytes_written,
 211                                 GError    **error)
 212 {
 213   const guint8 *in, *in_end;
 214   guint8 v, *out;
 215   gsize i;
 216   gsize block_size;
 217
 218   in = inbuf;
 219   out = outbuf;
 220   in_end = in + inbuf_size;
 221
 222   while (in < in_end)
 223     {
 224       v = *in;
 225
 226       if (v == 0)
 227         {
 228           block_size = 0;
 229           while (in+block_size < in_end && *(in+block_size) == 0)
 230             block_size ++;
 231         }
 232       else
 233         block_size = v * 1000;
 234
 235       /* Not enough data */
 236       if ((gsize) (in_end - in) < block_size)
 237         {
 238           if (*bytes_read > 0)
 239             break;
 240           g_set_error_literal (error, G_IO_ERROR,
 241                                G_IO_ERROR_PARTIAL_INPUT,
 242                                "Need more data");
 243           return G_CONVERTER_ERROR;
 244         }
 245
 246       for (i = 0; i < block_size; i++)
 247         {
 248           if (*(in + i) != v)
 249             {
 250               if (*bytes_read > 0)
 251                 break;
 252               g_set_error_literal (error, G_IO_ERROR,
 253                                    G_IO_ERROR_INVALID_DATA,
 254                                    "invalid data");
 255               return G_CONVERTER_ERROR;
 256             }
 257         }
 258
 259       if (v == 0 && (gsize) (in_end - in) == block_size && (flags & G_CONVERTER_INPUT_AT_END) == 0)
 260         {
 261           if (*bytes_read > 0)
 262             break;
 263           g_set_error_literal (error, G_IO_ERROR,
 264                                G_IO_ERROR_PARTIAL_INPUT,
 265                                "Need more data");
 266           return G_CONVERTER_ERROR;
 267         }
 268
 269       in += block_size;
 270       *out++ = v;
 271       *bytes_read += block_size;
 272       *bytes_written += 1;
 273     }
 274
 275   if (in == in_end && (flags & G_CONVERTER_INPUT_AT_END))
 276     return G_CONVERTER_FINISHED;
 277   return G_CONVERTER_CONVERTED;
 278 }
 279
 280 static void
 281 g_compressor_converter_iface_init (GConverterIface *iface)
 282 {
 283   iface->convert = g_compressor_converter_convert;
 284   iface->reset = g_compressor_converter_reset;
 285 }
 286
 287 guint8 unexpanded_data[] = { 0,1,3,4,5,6,7,3,12,0,0};
 288
 289 static void
 290 test_expander (void)
 291 {
 292   guint8 *converted1, *converted2, *ptr;
 293   gsize n_read, n_written;
 294   gsize total_read;
 295   gssize res;
 296   GConverterResult cres;
 297   GInputStream *mem, *cstream;
 298   GOutputStream *mem_out, *cstream_out;
 299   GConverter *expander;
 300   GConverter *converter;
 301   GError *error;
 302   gsize i;
 303
 304   expander = g_expander_converter_new ();
 305
 306   converted1 = g_malloc (100*1000); /* Large enough */
 307   converted2 = g_malloc (100*1000); /* Large enough */
 308
 309   cres = g_converter_convert (expander,
 310                               unexpanded_data, sizeof(unexpanded_data),
 311                               converted1, 100*1000,
 312                               G_CONVERTER_INPUT_AT_END,
 313                               &n_read, &n_written, NULL);
 314
 315   g_assert_cmpint (cres, ==, G_CONVERTER_FINISHED);
 316   g_assert_cmpuint (n_read, ==, 11);
 317   g_assert_cmpuint (n_written, ==, 41030);
 318
 319   g_converter_reset (expander);
 320
 321   mem = g_memory_input_stream_new_from_data (unexpanded_data,
 322                                              sizeof (unexpanded_data),
 323                                              NULL);
 324   cstream = g_converter_input_stream_new (mem, expander);
 325   g_assert_true (g_converter_input_stream_get_converter (G_CONVERTER_INPUT_STREAM (cstream)) == expander);
 326   g_object_get (cstream, "converter", &converter, NULL);
 327   g_assert_true (converter == expander);
 328   g_object_unref (converter);
 329   g_object_unref (mem);
 330
 331   total_read = 0;
 332   ptr = converted2;
 333   while (TRUE)
 334     {
 335       error = NULL;
 336       res = g_input_stream_read (cstream,
 337                                  ptr, 1,
 338                                  NULL, &error);
 339       g_assert_cmpint (res, !=, -1);
 340       if (res == 0)
 341         break;
 342       ptr += res;
 343       total_read += res;
 344     }
 345
 346   g_assert_cmpmem (converted1, n_written, converted2, total_read);
 347
 348   g_converter_reset (expander);
 349
 350   mem_out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 351   cstream_out = g_converter_output_stream_new (mem_out, expander);
 352   g_assert_true (g_converter_output_stream_get_converter (G_CONVERTER_OUTPUT_STREAM (cstream_out)) == expander);
 353   g_object_get (cstream_out, "converter", &converter, NULL);
 354   g_assert_true (converter == expander);
 355   g_object_unref (converter);
 356   g_object_unref (mem_out);
 357
 358   for (i = 0; i < sizeof(unexpanded_data); i++)
 359     {
 360       error = NULL;
 361       res = g_output_stream_write (cstream_out,
 362                                    unexpanded_data + i, 1,
 363                                    NULL, &error);
 364       g_assert_cmpint (res, !=, -1);
 365       if (res == 0)
 366         {
 367           g_assert_cmpuint (i, ==, sizeof(unexpanded_data) -1);
 368           break;
 369         }
 370       g_assert_cmpint (res, ==, 1);
 371     }
 372
 373   g_output_stream_close (cstream_out, NULL, NULL);
 374
 375   g_assert_cmpmem (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (mem_out)),
 376                    g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (mem_out)),
 377                    converted1, n_written);
 378
 379   g_free (converted1);
 380   g_free (converted2);
 381   g_object_unref (cstream);
 382   g_object_unref (cstream_out);
 383   g_object_unref (expander);
 384 }
 385
 386 static void
 387 test_compressor (void)
 388 {
 389   guint8 *converted, *expanded, *ptr;
 390   gsize n_read, expanded_size;
 391   gsize total_read;
 392   gssize res;
 393   GConverterResult cres;
 394   GInputStream *mem, *cstream;
 395   GOutputStream *mem_out, *cstream_out;
 396   GConverter *expander, *compressor;
 397   GError *error;
 398   gsize i;
 399
 400   expander = g_expander_converter_new ();
 401   expanded = g_malloc (100*1000); /* Large enough */
 402   cres = g_converter_convert (expander,
 403                               unexpanded_data, sizeof(unexpanded_data),
 404                               expanded, 100*1000,
 405                               G_CONVERTER_INPUT_AT_END,
 406                               &n_read, &expanded_size, NULL);
 407   g_assert_cmpint (cres, ==, G_CONVERTER_FINISHED);
 408   g_assert_cmpuint (n_read, ==, 11);
 409   g_assert_cmpuint (expanded_size, ==, 41030);
 410
 411   compressor = g_compressor_converter_new ();
 412
 413   converted = g_malloc (100*1000); /* Large enough */
 414
 415   mem = g_memory_input_stream_new_from_data (expanded,
 416                                              expanded_size,
 417                                              NULL);
 418   cstream = g_converter_input_stream_new (mem, compressor);
 419   g_object_unref (mem);
 420
 421   total_read = 0;
 422   ptr = converted;
 423   while (TRUE)
 424     {
 425       error = NULL;
 426       res = g_input_stream_read (cstream,
 427                                  ptr, 1,
 428                                  NULL, &error);
 429       g_assert_cmpint (res, !=, -1);
 430       if (res == 0)
 431         break;
 432       ptr += res;
 433       total_read += res;
 434     }
 435
 436   /* "n_read - 1" because last 2 zeros are combined */
 437   g_assert_cmpmem (unexpanded_data, n_read - 1, converted, total_read);
 438
 439   g_object_unref (cstream);
 440
 441   g_converter_reset (compressor);
 442
 443   mem_out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 444   cstream_out = g_converter_output_stream_new (mem_out, compressor);
 445   g_object_unref (mem_out);
 446
 447   for (i = 0; i < expanded_size; i++)
 448     {
 449       error = NULL;
 450       res = g_output_stream_write (cstream_out,
 451                                    expanded + i, 1,
 452                                    NULL, &error);
 453       g_assert_cmpint (res, !=, -1);
 454       if (res == 0)
 455         {
 456           g_assert_cmpuint (i, ==, expanded_size -1);
 457           break;
 458         }
 459       g_assert_cmpint (res, ==, 1);
 460     }
 461
 462   g_output_stream_close (cstream_out, NULL, NULL);
 463
 464   /* "n_read - 1" because last 2 zeros are combined */
 465   g_assert_cmpmem (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (mem_out)),
 466                    g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (mem_out)),
 467                    unexpanded_data,
 468                    n_read - 1);
 469
 470   g_object_unref (cstream_out);
 471
 472   g_converter_reset (compressor);
 473
 474   memset (expanded, 5, 5*1000*2);
 475
 476   mem = g_memory_input_stream_new_from_data (expanded,
 477                                              5*1000,
 478                                              NULL);
 479   cstream = g_converter_input_stream_new (mem, compressor);
 480   g_object_unref (mem);
 481
 482   total_read = 0;
 483   ptr = converted;
 484   while (TRUE)
 485     {
 486       error = NULL;
 487       res = g_input_stream_read (cstream,
 488                                  ptr, 1,
 489                                  NULL, &error);
 490       g_assert_cmpint (res, !=, -1);
 491       if (res == 0)
 492         break;
 493       ptr += res;
 494       total_read += res;
 495     }
 496
 497   g_assert_cmpuint (total_read, ==, 1);
 498   g_assert_cmpuint (*converted, ==, 5);
 499
 500   g_object_unref (cstream);
 501
 502   mem = g_memory_input_stream_new_from_data (expanded,
 503                                              5*1000 * 2,
 504                                              NULL);
 505   cstream = g_converter_input_stream_new (mem, compressor);
 506   g_object_unref (mem);
 507
 508   total_read = 0;
 509   ptr = converted;
 510   while (TRUE)
 511     {
 512       error = NULL;
 513       res = g_input_stream_read (cstream,
 514                                  ptr, 1,
 515                                  NULL, &error);
 516       g_assert_cmpint (res, !=, -1);
 517       if (res == 0)
 518         break;
 519       ptr += res;
 520       total_read += res;
 521     }
 522
 523   g_assert_cmpuint (total_read, ==, 2);
 524   g_assert_cmpuint (converted[0], ==, 5);
 525   g_assert_cmpuint (converted[1], ==, 5);
 526
 527   g_object_unref (cstream);
 528
 529   g_converter_reset (compressor);
 530
 531   mem = g_memory_input_stream_new_from_data (expanded,
 532                                              5*1000 * 2 - 1,
 533                                              NULL);
 534   cstream = g_converter_input_stream_new (mem, compressor);
 535   g_object_unref (mem);
 536
 537   total_read = 0;
 538   ptr = converted;
 539   while (TRUE)
 540     {
 541       error = NULL;
 542       res = g_input_stream_read (cstream,
 543                                  ptr, 1,
 544                                  NULL, &error);
 545       if (res == -1)
 546         {
 547           g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT);
 548           g_error_free (error);
 549           break;
 550         }
 551
 552       g_assert_cmpint (res, !=, 0);
 553       ptr += res;
 554       total_read += res;
 555     }
 556
 557   g_assert_cmpuint (total_read, ==, 1);
 558   g_assert_cmpuint (converted[0], ==, 5);
 559
 560   g_object_unref (cstream);
 561
 562   g_free (expanded);
 563   g_free (converted);
 564   g_object_unref (expander);
 565   g_object_unref (compressor);
 566 }
 567
 568 #define LEFTOVER_SHORT_READ_SIZE 512
 569
 570 #define G_TYPE_LEFTOVER_CONVERTER         (g_leftover_converter_get_type ())
 571 #define G_LEFTOVER_CONVERTER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_LEFTOVER_CONVERTER, GLeftoverConverter))
 572 #define G_LEFTOVER_CONVERTER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_LEFTOVER_CONVERTER, GLeftoverConverterClass))
 573 #define G_IS_LEFTOVER_CONVERTER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_LEFTOVER_CONVERTER))
 574 #define G_IS_LEFTOVER_CONVERTER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_LEFTOVER_CONVERTER))
 575 #define G_LEFTOVER_CONVERTER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_LEFTOVER_CONVERTER, GLeftoverConverterClass))
 576
 577 typedef struct _GLeftoverConverter       GLeftoverConverter;
 578 typedef struct _GLeftoverConverterClass  GLeftoverConverterClass;
 579
 580 struct _GLeftoverConverterClass
 581 {
 582   GObjectClass parent_class;
 583 };
 584
 585 GType       g_leftover_converter_get_type (void) G_GNUC_CONST;
 586 GConverter *g_leftover_converter_new      (void);
 587
 588
 589
 590 static void g_leftover_converter_iface_init          (GConverterIface *iface);
 591
 592 struct _GLeftoverConverter
 593 {
 594   GObject parent_instance;
 595 };
 596
 597 G_DEFINE_TYPE_WITH_CODE (GLeftoverConverter, g_leftover_converter, G_TYPE_OBJECT,
 598                          G_IMPLEMENT_INTERFACE (G_TYPE_CONVERTER,
 599                                                 g_leftover_converter_iface_init))
 600
 601 static void
 602 g_leftover_converter_class_init (GLeftoverConverterClass *klass)
 603 {
 604 }
 605
 606 static void
 607 g_leftover_converter_init (GLeftoverConverter *local)
 608 {
 609 }
 610
 611 GConverter *
 612 g_leftover_converter_new (void)
 613 {
 614   GConverter *conv;
 615
 616   conv = g_object_new (G_TYPE_LEFTOVER_CONVERTER, NULL);
 617
 618   return conv;
 619 }
 620
 621 static void
 622 g_leftover_converter_reset (GConverter *converter)
 623 {
 624 }
 625
 626 static GConverterResult
 627 g_leftover_converter_convert (GConverter *converter,
 628                               const void *inbuf,
 629                               gsize       inbuf_size,
 630                               void       *outbuf,
 631                               gsize       outbuf_size,
 632                               GConverterFlags flags,
 633                               gsize      *bytes_read,
 634                               gsize      *bytes_written,
 635                               GError    **error)
 636 {
 637   if (outbuf_size == LEFTOVER_SHORT_READ_SIZE)
 638     {
 639       g_set_error_literal (error,
 640                            G_IO_ERROR,
 641                            G_IO_ERROR_PARTIAL_INPUT,
 642                            "partial input");
 643       return G_CONVERTER_ERROR;
 644     }
 645
 646   if (inbuf_size < 100)
 647     *bytes_read = *bytes_written = MIN (inbuf_size, outbuf_size);
 648   else
 649     *bytes_read = *bytes_written = MIN (inbuf_size - 10, outbuf_size);
 650   memcpy (outbuf, inbuf, *bytes_written);
 651
 652   if (*bytes_read == inbuf_size && (flags & G_CONVERTER_INPUT_AT_END))
 653     return G_CONVERTER_FINISHED;
 654   return G_CONVERTER_CONVERTED;
 655 }
 656
 657 static void
 658 g_leftover_converter_iface_init (GConverterIface *iface)
 659 {
 660   iface->convert = g_leftover_converter_convert;
 661   iface->reset = g_leftover_converter_reset;
 662 }
 663
 664 #define LEFTOVER_BUFSIZE 8192
 665 #define INTERNAL_BUFSIZE 4096
 666
 667 static void
 668 test_converter_leftover (void)
 669 {
 670   gchar *orig, *converted;
 671   gsize total_read;
 672   gssize res;
 673   goffset offset;
 674   GInputStream *mem, *cstream;
 675   GConverter *converter;
 676   GError *error;
 677   int i;
 678
 679   converter = g_leftover_converter_new ();
 680
 681   orig = g_malloc (LEFTOVER_BUFSIZE);
 682   converted = g_malloc (LEFTOVER_BUFSIZE);
 683   for (i = 0; i < LEFTOVER_BUFSIZE; i++)
 684     orig[i] = i % 64 + 32;
 685
 686   mem = g_memory_input_stream_new_from_data (orig, LEFTOVER_BUFSIZE, NULL);
 687   cstream = g_converter_input_stream_new (mem, G_CONVERTER (converter));
 688   g_object_unref (mem);
 689
 690   total_read = 0;
 691
 692   error = NULL;
 693   res = g_input_stream_read (cstream,
 694                              converted, LEFTOVER_SHORT_READ_SIZE,
 695                              NULL, &error);
 696   g_assert_cmpint (res, ==, LEFTOVER_SHORT_READ_SIZE);
 697   total_read += res;
 698
 699   offset = g_seekable_tell (G_SEEKABLE (mem));
 700   g_assert_cmpint (offset, >, LEFTOVER_SHORT_READ_SIZE);
 701   g_assert_cmpint (offset, <, LEFTOVER_BUFSIZE);
 702
 703   /* At this point, @cstream has both a non-empty input_buffer
 704    * and a non-empty converted_buffer, which is the case
 705    * we want to test.
 706    */
 707
 708   while (TRUE)
 709     {
 710       error = NULL;
 711       res = g_input_stream_read (cstream,
 712                                  converted + total_read,
 713                                  LEFTOVER_BUFSIZE - total_read,
 714                                  NULL, &error);
 715       g_assert_cmpint (res, >=, 0);
 716       if (res == 0)
 717         break;
 718       total_read += res;
 719   }
 720
 721   g_assert_cmpmem (orig, LEFTOVER_BUFSIZE, converted, total_read);
 722
 723   g_object_unref (cstream);
 724   g_free (orig);
 725   g_free (converted);
 726   g_object_unref (converter);
 727 }
 728
 729 #define DATA_LENGTH 1000000
 730
 731 typedef struct {
 732   const gchar *path;
 733   GZlibCompressorFormat format;
 734   gint level;
 735 } CompressorTest;
 736
 737 static void
 738 test_roundtrip (gconstpointer data)
 739 {
 740   const CompressorTest *test = data;
 741   GError *error = NULL;
 742   guint32 *data0, *data1;
 743   gsize data1_size;
 744   gint i;
 745   GInputStream *istream0, *istream1, *cistream1;
 746   GOutputStream *ostream1, *ostream2, *costream1;
 747   GConverter *compressor, *decompressor;
 748   GZlibCompressorFormat fmt;
 749   gint lvl;
 750   GFileInfo *info;
 751   GFileInfo *info2;
 752
 753   g_test_bug ("https://bugzilla.gnome.org/show_bug.cgi?id=619945");
 754
 755   data0 = g_malloc (DATA_LENGTH * sizeof (guint32));
 756   for (i = 0; i < DATA_LENGTH; i++)
 757     data0[i] = g_random_int ();
 758
 759   istream0 = g_memory_input_stream_new_from_data (data0,
 760     DATA_LENGTH * sizeof (guint32), NULL);
 761
 762   ostream1 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 763   compressor = G_CONVERTER (g_zlib_compressor_new (test->format, test->level));
 764   info = g_file_info_new ();
 765   g_file_info_set_name (info, "foo");
 766   g_object_set (compressor, "file-info", info, NULL);
 767   info2 = g_zlib_compressor_get_file_info (G_ZLIB_COMPRESSOR (compressor));
 768   g_assert_true (info == info2);
 769   g_object_unref (info);
 770   costream1 = g_converter_output_stream_new (ostream1, compressor);
 771   g_assert_true (g_converter_output_stream_get_converter (G_CONVERTER_OUTPUT_STREAM (costream1)) == compressor);
 772
 773   g_output_stream_splice (costream1, istream0, 0, NULL, &error);
 774   g_assert_no_error (error);
 775
 776   g_object_unref (costream1);
 777
 778   g_converter_reset (compressor);
 779   g_object_get (compressor, "format", &fmt, "level", &lvl, NULL);
 780   g_assert_cmpint (fmt, ==, test->format);
 781   g_assert_cmpint (lvl, ==, test->level);
 782   g_object_unref (compressor);
 783   data1 = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (ostream1));
 784   data1_size = g_memory_output_stream_get_data_size (
 785     G_MEMORY_OUTPUT_STREAM (ostream1));
 786   g_object_unref (ostream1);
 787   g_object_unref (istream0);
 788
 789   istream1 = g_memory_input_stream_new_from_data (data1, data1_size, g_free);
 790   decompressor = G_CONVERTER (g_zlib_decompressor_new (test->format));
 791   cistream1 = g_converter_input_stream_new (istream1, decompressor);
 792
 793   ostream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 794
 795   g_output_stream_splice (ostream2, cistream1, 0, NULL, &error);
 796   g_assert_no_error (error);
 797
 798   g_assert_cmpmem (data0, DATA_LENGTH * sizeof (guint32),
 799                    g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (ostream2)),
 800                    g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (ostream2)));
 801   g_object_unref (istream1);
 802   g_converter_reset (decompressor);
 803   g_object_get (decompressor, "format", &fmt, NULL);
 804   g_assert_cmpint (fmt, ==, test->format);
 805   g_object_unref (decompressor);
 806   g_object_unref (cistream1);
 807   g_object_unref (ostream2);
 808   g_free (data0);
 809 }
 810
 811 typedef struct {
 812   const gchar *path;
 813   const gchar *charset_in;
 814   const gchar *text_in;
 815   const gchar *charset_out;
 816   const gchar *text_out;
 817   gint n_fallbacks;
 818 } CharsetTest;
 819
 820 static void
 821 test_charset (gconstpointer data)
 822 {
 823   const CharsetTest *test = data;
 824   GInputStream *in, *in2;
 825   GConverter *conv;
 826   gchar *buffer;
 827   gsize count;
 828   gsize bytes_read;
 829   GError *error;
 830   gboolean fallback;
 831
 832   conv = (GConverter *)g_charset_converter_new (test->charset_out, test->charset_in, NULL);
 833   g_object_get (conv, "use-fallback", &fallback, NULL);
 834   g_assert_false (fallback);
 835
 836   in = g_memory_input_stream_new_from_data (test->text_in, -1, NULL);
 837   in2 = g_converter_input_stream_new (in, conv);
 838
 839   count = 2 * strlen (test->text_out);
 840   buffer = g_malloc0 (count);
 841   error = NULL;
 842   g_input_stream_read_all (in2, buffer, count, &bytes_read, NULL, &error);
 843   if (test->n_fallbacks == 0)
 844     {
 845       g_assert_no_error (error);
 846       g_assert_cmpint (bytes_read, ==, strlen (test->text_out));
 847       g_assert_cmpstr (buffer, ==, test->text_out);
 848     }
 849   else
 850     {
 851       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA);
 852       g_error_free (error);
 853     }
 854
 855   g_free (buffer);
 856   g_object_unref (in2);
 857   g_object_unref (in);
 858
 859   if (test->n_fallbacks == 0)
 860     {
 861        g_object_unref (conv);
 862        return;
 863     }
 864
 865   g_converter_reset (conv);
 866
 867   g_assert_false (g_charset_converter_get_use_fallback (G_CHARSET_CONVERTER (conv)));
 868   g_charset_converter_set_use_fallback (G_CHARSET_CONVERTER (conv), TRUE);
 869
 870   in = g_memory_input_stream_new_from_data (test->text_in, -1, NULL);
 871   in2 = g_converter_input_stream_new (in, conv);
 872
 873   count = 2 * strlen (test->text_out);
 874   buffer = g_malloc0 (count);
 875   error = NULL;
 876   g_input_stream_read_all (in2, buffer, count, &bytes_read, NULL, &error);
 877   g_assert_no_error (error);
 878   g_assert_cmpstr (buffer, ==, test->text_out);
 879   g_assert_cmpint (bytes_read, ==, strlen (test->text_out));
 880   g_assert_cmpint (test->n_fallbacks, ==, g_charset_converter_get_num_fallbacks (G_CHARSET_CONVERTER (conv)));
 881
 882   g_free (buffer);
 883   g_object_unref (in2);
 884   g_object_unref (in);
 885
 886   g_object_unref (conv);
 887 }
 888
 889
 890 static void
 891 client_connected (GObject      *source,
 892                   GAsyncResult *result,
 893                   gpointer      user_data)
 894 {
 895   GSocketClient *client = G_SOCKET_CLIENT (source);
 896   GSocketConnection **conn = user_data;
 897   GError *error = NULL;
 898
 899   *conn = g_socket_client_connect_finish (client, result, &error);
 900   g_assert_no_error (error);
 901 }
 902
 903 static void
 904 server_connected (GObject      *source,
 905                   GAsyncResult *result,
 906                   gpointer      user_data)
 907 {
 908   GSocketListener *listener = G_SOCKET_LISTENER (source);
 909   GSocketConnection **conn = user_data;
 910   GError *error = NULL;
 911
 912   *conn = g_socket_listener_accept_finish (listener, result, NULL, &error);
 913   g_assert_no_error (error);
 914 }
 915
 916 static void
 917 make_socketpair (GIOStream **left,
 918                  GIOStream **right)
 919 {
 920   GInetAddress *iaddr;
 921   GSocketAddress *saddr, *effective_address;
 922   GSocketListener *listener;
 923   GSocketClient *client;
 924   GError *error = NULL;
 925   GSocketConnection *client_conn = NULL, *server_conn = NULL;
 926
 927   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
 928   saddr = g_inet_socket_address_new (iaddr, 0);
 929   g_object_unref (iaddr);
 930
 931   listener = g_socket_listener_new ();
 932   g_socket_listener_add_address (listener, saddr,
 933                                  G_SOCKET_TYPE_STREAM,
 934                                  G_SOCKET_PROTOCOL_TCP,
 935                                  NULL,
 936                                  &effective_address,
 937                                  &error);
 938   g_assert_no_error (error);
 939   g_object_unref (saddr);
 940
 941   client = g_socket_client_new ();
 942
 943   g_socket_client_connect_async (client,
 944                                  G_SOCKET_CONNECTABLE (effective_address),
 945                                  NULL, client_connected, &client_conn);
 946   g_socket_listener_accept_async (listener, NULL,
 947                                   server_connected, &server_conn);
 948
 949   while (!client_conn || !server_conn)
 950     g_main_context_iteration (NULL, TRUE);
 951
 952   g_object_unref (client);
 953   g_object_unref (listener);
 954   g_object_unref (effective_address);
 955
 956   *left = G_IO_STREAM (client_conn);
 957   *right = G_IO_STREAM (server_conn);
 958 }
 959
 960 static void
 961 test_converter_pollable (void)
 962 {
 963   GIOStream *left, *right;
 964   guint8 *converted, *inptr;
 965   guint8 *expanded, *outptr, *expanded_end;
 966   gsize n_read, expanded_size;
 967   gsize total_read;
 968   gssize res;
 969   gboolean is_readable;
 970   GConverterResult cres;
 971   GInputStream *cstream;
 972   GPollableInputStream *pollable_in;
 973   GOutputStream *socket_out, *mem_out, *cstream_out;
 974   GPollableOutputStream *pollable_out;
 975   GConverter *expander, *compressor;
 976   GError *error;
 977   gsize i;
 978
 979   expander = g_expander_converter_new ();
 980   expanded = g_malloc (100*1000); /* Large enough */
 981   cres = g_converter_convert (expander,
 982                               unexpanded_data, sizeof(unexpanded_data),
 983                               expanded, 100*1000,
 984                               G_CONVERTER_INPUT_AT_END,
 985                               &n_read, &expanded_size, NULL);
 986   g_assert_cmpint (cres, ==, G_CONVERTER_FINISHED);
 987   g_assert_cmpuint (n_read, ==, 11);
 988   g_assert_cmpuint (expanded_size, ==, 41030);
 989   expanded_end = expanded + expanded_size;
 990
 991   make_socketpair (&left, &right);
 992
 993   compressor = g_compressor_converter_new ();
 994
 995   converted = g_malloc (100*1000); /* Large enough */
 996
 997   cstream = g_converter_input_stream_new (g_io_stream_get_input_stream (left),
 998                                           compressor);
 999   pollable_in = G_POLLABLE_INPUT_STREAM (cstream);
1000   g_assert_true (g_pollable_input_stream_can_poll (pollable_in));
1001
1002   socket_out = g_io_stream_get_output_stream (right);
1003
1004   total_read = 0;
1005   outptr = expanded;
1006   inptr = converted;
1007   while (TRUE)
1008     {
1009       error = NULL;
1010
1011       if (outptr < expanded_end)
1012         {
1013            res = g_output_stream_write (socket_out,
1014                                        outptr,
1015                                        MIN (1000, (expanded_end - outptr)),
1016                                        NULL, &error);
1017           g_assert_cmpint (res, >, 0);
1018           outptr += res;
1019         }
1020       else if (socket_out)
1021         {
1022           g_output_stream_close (socket_out, NULL, NULL);
1023           g_object_unref (right);
1024           socket_out = NULL;
1025         }
1026
1027       /* Wait a few ticks to check for the pipe to propagate the
1028        * write. We can’t wait on a GSource as that might affect the stream under
1029        * test, so just poll. */
1030       while (!g_pollable_input_stream_is_readable (pollable_in))
1031         g_usleep (80L);
1032
1033       is_readable = g_pollable_input_stream_is_readable (pollable_in);
1034       res = g_pollable_input_stream_read_nonblocking (pollable_in,
1035                                                       inptr, 1,
1036                                                       NULL, &error);
1037
1038       /* is_readable can be a false positive, but not a false negative */
1039       if (!is_readable)
1040         g_assert_cmpint (res, ==, -1);
1041
1042       /* Even after closing the write end, we can get WOULD_BLOCK (particularly
1043        * on FreeBSD), so we can’t make any assertions based on `!socket_out`.
1044        * This is because the FIN packets may still be in the out buffer of one
1045        * half of the socket pair, while the in buffer of the other half has some
1046        * data, but not enough for a full block for the converter to consume. */
1047
1048       if (res == -1)
1049         {
1050           g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1051           g_error_free (error);
1052
1053           continue;
1054         }
1055
1056       if (res == 0)
1057         break;
1058       inptr += res;
1059       total_read += res;
1060     }
1061
1062   /* "n_read - 1" because last 2 zeros are combined */
1063   g_assert_cmpmem (unexpanded_data, n_read - 1, converted, total_read);
1064
1065   g_object_unref (cstream);
1066   g_object_unref (left);
1067
1068   g_converter_reset (compressor);
1069
1070   /* This doesn't actually test the behavior on
1071    * G_IO_ERROR_WOULD_BLOCK; to do that we'd need to implement a
1072    * custom GOutputStream that we could control blocking on.
1073    */
1074
1075   mem_out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
1076   cstream_out = g_converter_output_stream_new (mem_out, compressor);
1077   g_object_unref (mem_out);
1078   pollable_out = G_POLLABLE_OUTPUT_STREAM (cstream_out);
1079   g_assert_true (g_pollable_output_stream_can_poll (pollable_out));
1080   g_assert_true (g_pollable_output_stream_is_writable (pollable_out));
1081
1082   for (i = 0; i < expanded_size; i++)
1083     {
1084       error = NULL;
1085       res = g_pollable_output_stream_write_nonblocking (pollable_out,
1086                                                         expanded + i, 1,
1087                                                         NULL, &error);
1088       g_assert_cmpint (res, !=, -1);
1089       if (res == 0)
1090         {
1091           g_assert_cmpuint (i, ==, expanded_size -1);
1092           break;
1093         }
1094       g_assert_cmpint (res, ==, 1);
1095     }
1096
1097   g_output_stream_close (cstream_out, NULL, NULL);
1098
1099   /* "n_read - 1" because last 2 zeros are combined */
1100   g_assert_cmpmem (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (mem_out)),
1101                    g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (mem_out)),
1102                    unexpanded_data,
1103                    n_read - 1);
1104
1105   g_object_unref (cstream_out);
1106
1107   g_free (expanded);
1108   g_free (converted);
1109   g_object_unref (expander);
1110   g_object_unref (compressor);
1111 }
1112
1113 static void
1114 test_truncation (gconstpointer data)
1115 {
1116   const CompressorTest *test = data;
1117   GError *error = NULL;
1118   guint32 *data0, *data1;
1119   gsize data1_size;
1120   gint i;
1121   GInputStream *istream0, *istream1, *cistream1;
1122   GOutputStream *ostream1, *ostream2, *costream1;
1123   GConverter *compressor, *decompressor;
1124
1125   data0 = g_malloc (DATA_LENGTH * sizeof (guint32));
1126   for (i = 0; i < DATA_LENGTH; i++)
1127     data0[i] = g_random_int ();
1128
1129   istream0 = g_memory_input_stream_new_from_data (data0,
1130     DATA_LENGTH * sizeof (guint32), NULL);
1131
1132   ostream1 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
1133   compressor = G_CONVERTER (g_zlib_compressor_new (test->format, -1));
1134   costream1 = g_converter_output_stream_new (ostream1, compressor);
1135   g_assert_true (g_converter_output_stream_get_converter (G_CONVERTER_OUTPUT_STREAM (costream1)) == compressor);
1136
1137   g_output_stream_splice (costream1, istream0, 0, NULL, &error);
1138   g_assert_no_error (error);
1139
1140   g_object_unref (costream1);
1141   g_object_unref (compressor);
1142
1143   data1 = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (ostream1));
1144   data1_size = g_memory_output_stream_get_data_size (
1145     G_MEMORY_OUTPUT_STREAM (ostream1));
1146   g_object_unref (ostream1);
1147   g_object_unref (istream0);
1148
1149   /* truncate */
1150   data1_size /= 2;
1151
1152   istream1 = g_memory_input_stream_new_from_data (data1, data1_size, g_free);
1153   decompressor = G_CONVERTER (g_zlib_decompressor_new (test->format));
1154   cistream1 = g_converter_input_stream_new (istream1, decompressor);
1155
1156   ostream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
1157
1158   g_output_stream_splice (ostream2, cistream1, 0, NULL, &error);
1159   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT);
1160   g_error_free (error);
1161
1162   g_object_unref (istream1);
1163   g_object_unref (decompressor);
1164   g_object_unref (cistream1);
1165   g_object_unref (ostream2);
1166   g_free (data0);
1167 }
1168
1169 static void
1170 test_converter_basics (void)
1171 {
1172   GConverter *converter;
1173   GError *error = NULL;
1174   gchar *to;
1175   gchar *from;
1176
1177   converter = (GConverter *)g_charset_converter_new ("utf-8", "latin1", &error);
1178   g_assert_no_error (error);
1179   g_object_get (converter,
1180                 "to-charset", &to,
1181                 "from-charset", &from,
1182                 NULL);
1183
1184   g_assert_cmpstr (to, ==, "utf-8");
1185   g_assert_cmpstr (from, ==, "latin1");
1186
1187   g_free (to);
1188   g_free (from);
1189   g_object_unref (converter);
1190 }
1191
1192 int
1193 main (int   argc,
1194       char *argv[])
1195 {
1196   CompressorTest compressor_tests[] = {
1197     { "/converter-output-stream/roundtrip/zlib-0", G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 0 },
1198     { "/converter-output-stream/roundtrip/zlib-9", G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 9 },
1199     { "/converter-output-stream/roundtrip/gzip-0", G_ZLIB_COMPRESSOR_FORMAT_GZIP, 0 },
1200     { "/converter-output-stream/roundtrip/gzip-9", G_ZLIB_COMPRESSOR_FORMAT_GZIP, 9 },
1201     { "/converter-output-stream/roundtrip/raw-0", G_ZLIB_COMPRESSOR_FORMAT_RAW, 0 },
1202     { "/converter-output-stream/roundtrip/raw-9", G_ZLIB_COMPRESSOR_FORMAT_RAW, 9 },
1203   };
1204   CompressorTest truncation_tests[] = {
1205     { "/converter-input-stream/truncation/zlib", G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 0 },
1206     { "/converter-input-stream/truncation/gzip", G_ZLIB_COMPRESSOR_FORMAT_GZIP, 0 },
1207     { "/converter-input-stream/truncation/raw", G_ZLIB_COMPRESSOR_FORMAT_RAW, 0 },
1208   };
1209   CharsetTest charset_tests[] = {
1210     { "/converter-input-stream/charset/utf8->latin1", "UTF-8", "\303\205rr Sant\303\251", "ISO-8859-1", "\305rr Sant\351", 0 },
1211     { "/converter-input-stream/charset/latin1->utf8", "ISO-8859-1", "\305rr Sant\351", "UTF-8", "\303\205rr Sant\303\251", 0 },
1212     { "/converter-input-stream/charset/fallbacks", "UTF-8", "Some characters just don't fit into latin1: πא", "ISO-8859-1", "Some characters just don't fit into latin1: \\CF\\80\\D7\\90", 4 },
1213   };
1214
1215   gsize i;
1216
1217   g_test_init (&argc, &argv, NULL);
1218
1219   g_test_add_func ("/converter/basics", test_converter_basics);
1220   g_test_add_func ("/converter-input-stream/expander", test_expander);
1221   g_test_add_func ("/converter-input-stream/compressor", test_compressor);
1222
1223   for (i = 0; i < G_N_ELEMENTS (compressor_tests); i++)
1224     g_test_add_data_func (compressor_tests[i].path, &compressor_tests[i], test_roundtrip);
1225
1226   for (i = 0; i < G_N_ELEMENTS (truncation_tests); i++)
1227     g_test_add_data_func (truncation_tests[i].path, &truncation_tests[i], test_truncation);
1228
1229   for (i = 0; i < G_N_ELEMENTS (charset_tests); i++)
1230     g_test_add_data_func (charset_tests[i].path, &charset_tests[i], test_charset);
1231
1232   g_test_add_func ("/converter-stream/pollable", test_converter_pollable);
1233   g_test_add_func ("/converter-stream/leftover", test_converter_leftover);
1234
1235   return g_test_run();
1236 }