gio/tests/filter-streams.c - third_party/glib - Git at Google

 /*
  * Copyright © 2009 Codethink Limited
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * See the included COPYING file for more information.
  *
  * Author: Ryan Lortie <desrt@desrt.ca>
  */

 #include <string.h>
 #include <glib/glib.h>
 #include <gio/gio.h>

 /* GFilterInputStream and GFilterOutputStream are abstract, so define
  * minimal subclasses for testing. (This used to use
  * GBufferedInputStream and GBufferedOutputStream, but those have
  * their own test program, and they override some methods, meaning the
  * core filter stream functionality wasn't getting fully tested.)
  */

 GType test_filter_input_stream_get_type (void);
 GType test_filter_output_stream_get_type (void);

 #define TEST_TYPE_FILTER_INPUT_STREAM  (test_filter_input_stream_get_type ())
 #define TEST_FILTER_INPUT_STREAM(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), TEST_TYPE_FILTER_INPUT_STREAM, TestFilterInputStream))
 #define TEST_TYPE_FILTER_OUTPUT_STREAM (test_filter_output_stream_get_type ())
 #define TEST_FILTER_OUTPUT_STREAM(o)   (G_TYPE_CHECK_INSTANCE_CAST ((o), TEST_TYPE_FILTER_OUTPUT_STREAM, TestFilterOutputStream))

 typedef GFilterInputStream       TestFilterInputStream;
 typedef GFilterInputStreamClass  TestFilterInputStreamClass;
 typedef GFilterOutputStream      TestFilterOutputStream;
 typedef GFilterOutputStreamClass TestFilterOutputStreamClass;

 G_DEFINE_TYPE (TestFilterInputStream, test_filter_input_stream, G_TYPE_FILTER_INPUT_STREAM)
 G_DEFINE_TYPE (TestFilterOutputStream, test_filter_output_stream, G_TYPE_FILTER_OUTPUT_STREAM)

 static void
 test_filter_input_stream_init (TestFilterInputStream *stream)
 {
 }

 static void
 test_filter_input_stream_class_init (TestFilterInputStreamClass *klass)
 {
 }

 static void
 test_filter_output_stream_init (TestFilterOutputStream *stream)
 {
 }

 static void
 test_filter_output_stream_class_init (TestFilterOutputStreamClass *klass)
 {
 }

 /* Now the tests */

 static void
 test_input_filter (void)
 {
   GInputStream *base, *f1, *f2, *s;
   gboolean close_base;
   gchar buf[1024];
   GError *error = NULL;

   g_test_bug ("568394");
   base = g_memory_input_stream_new_from_data ("abcdefghijk", -1, NULL);
   f1 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
                      "base-stream", base,
                      "close-base-stream", FALSE,
                      NULL);
   f2 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
                      "base-stream", base,
                      NULL);

   g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f1)) == base);
   g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f2)) == base);

   g_assert (!g_input_stream_is_closed (base));
   g_assert (!g_input_stream_is_closed (f1));
   g_assert (!g_input_stream_is_closed (f2));

   g_object_get (f1,
                 "close-base-stream", &close_base,
                 "base-stream", &s,
                 NULL);
   g_assert (!close_base);
   g_assert (s == base);
   g_object_unref (s);

   g_object_unref (f1);

   g_assert (!g_input_stream_is_closed (base));
   g_assert (!g_input_stream_is_closed (f2));

   g_input_stream_skip (f2, 3, NULL, &error);
   g_assert_no_error (error);

   memset (buf, 0, 1024);
   g_input_stream_read_all (f2, buf, 1024, NULL, NULL, &error);
   g_assert_no_error (error);
   g_assert_cmpstr (buf, ==, "defghijk");

   g_object_unref (f2);

   g_assert (g_input_stream_is_closed (base));

   g_object_unref (base);
 }

 static void
 test_output_filter (void)
 {
   GOutputStream *base, *f1, *f2;

   base = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
   f1 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
                      "base-stream", base,
                      "close-base-stream", FALSE,
                      NULL);
   f2 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
                      "base-stream", base,
                      NULL);

   g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f1)) == base);
   g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f2)) == base);

   g_assert (!g_output_stream_is_closed (base));
   g_assert (!g_output_stream_is_closed (f1));
   g_assert (!g_output_stream_is_closed (f2));

   g_object_unref (f1);

   g_assert (!g_output_stream_is_closed (base));
   g_assert (!g_output_stream_is_closed (f2));

   g_object_unref (f2);

   g_assert (g_output_stream_is_closed (base));

   g_object_unref (base);
 }

 gpointer expected_obj;
 gpointer expected_data;
 gboolean callback_happened;
 GMainLoop *loop;

 static void
 return_result_cb (GObject      *object,
                   GAsyncResult *result,
                   gpointer      user_data)
 {
   GAsyncResult **ret = user_data;

   *ret = g_object_ref (result);
   g_main_loop_quit (loop);
 }

 static void
 in_cb (GObject      *object,
        GAsyncResult *result,
        gpointer      user_data)
 {
   GError *error = NULL;

   g_assert (object == expected_obj);
   g_assert (user_data == expected_data);
   g_assert (callback_happened == FALSE);

   g_input_stream_close_finish (expected_obj, result, &error);
   g_assert (error == NULL);

   callback_happened = TRUE;
   g_main_loop_quit (loop);
 }

 static void
 test_input_async (void)
 {
   GInputStream *base, *f1, *f2;
   char buf[20];
   GAsyncResult *result = NULL;
   GError *error = NULL;

   loop = g_main_loop_new (NULL, FALSE);

   base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyz", -1, NULL);
   f1 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
                      "base-stream", base,
                      "close-base-stream", FALSE,
                      NULL);
   f2 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
                      "base-stream", base,
                      NULL);

   g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f1)) == base);
   g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f2)) == base);


   memset (buf, 0, sizeof (buf));
   g_input_stream_read_async (f1, buf, 10, G_PRIORITY_DEFAULT,
                              NULL, return_result_cb, &result);
   g_main_loop_run (loop);
   g_assert_cmpint (g_input_stream_read_finish (f1, result, &error), ==, 10);
   g_assert_cmpstr (buf, ==, "abcdefghij");
   g_assert_no_error (error);
   g_clear_object (&result);

   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 10);

   g_input_stream_skip_async (f2, 10, G_PRIORITY_DEFAULT,
                              NULL, return_result_cb, &result);
   g_main_loop_run (loop);
   g_assert_cmpint (g_input_stream_skip_finish (f2, result, &error), ==, 10);
   g_assert_no_error (error);
   g_clear_object (&result);

   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 20);

   memset (buf, 0, sizeof (buf));
   g_input_stream_read_async (f1, buf, 10, G_PRIORITY_DEFAULT,
                              NULL, return_result_cb, &result);
   g_main_loop_run (loop);
   g_assert_cmpint (g_input_stream_read_finish (f1, result, &error), ==, 6);
   g_assert_cmpstr (buf, ==, "uvwxyz");
   g_assert_no_error (error);
   g_clear_object (&result);

   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 26);


   g_assert (!g_input_stream_is_closed (base));
   g_assert (!g_input_stream_is_closed (f1));
   g_assert (!g_input_stream_is_closed (f2));

   expected_obj = f1;
   expected_data = g_malloc (20);
   callback_happened = FALSE;
   g_input_stream_close_async (f1, 0, NULL, in_cb, expected_data);

   g_assert (callback_happened == FALSE);
   g_main_loop_run (loop);
   g_assert (callback_happened == TRUE);

   g_assert (!g_input_stream_is_closed (base));
   g_assert (!g_input_stream_is_closed (f2));
   g_free (expected_data);
   g_object_unref (f1);
   g_assert (!g_input_stream_is_closed (base));
   g_assert (!g_input_stream_is_closed (f2));

   expected_obj = f2;
   expected_data = g_malloc (20);
   callback_happened = FALSE;
   g_input_stream_close_async (f2, 0, NULL, in_cb, expected_data);

   g_assert (callback_happened == FALSE);
   g_main_loop_run (loop);
   g_assert (callback_happened == TRUE);

   g_assert (g_input_stream_is_closed (base));
   g_assert (g_input_stream_is_closed (f2));
   g_free (expected_data);
   g_object_unref (f2);

   g_assert (g_input_stream_is_closed (base));
   g_object_unref (base);
   g_main_loop_unref (loop);
 }

 static void
 out_cb (GObject      *object,
         GAsyncResult *result,
         gpointer      user_data)
 {
   GError *error = NULL;

   g_assert (object == expected_obj);
   g_assert (user_data == expected_data);
   g_assert (callback_happened == FALSE);

   g_output_stream_close_finish (expected_obj, result, &error);
   g_assert (error == NULL);

   callback_happened = TRUE;
   g_main_loop_quit (loop);
 }

 static void
 test_output_async (void)
 {
   GOutputStream *base, *f1, *f2;
   GAsyncResult *result = NULL;
   GError *error = NULL;

   loop = g_main_loop_new (NULL, FALSE);

   base = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
   f1 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
                      "base-stream", base,
                      "close-base-stream", FALSE,
                      NULL);
   f2 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
                      "base-stream", base,
                      NULL);

   g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f1)) == base);
   g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f2)) == base);


   g_output_stream_write_async (f1, "abcdefghijklm", 13, G_PRIORITY_DEFAULT,
                                NULL, return_result_cb, &result);
   g_main_loop_run (loop);
   g_assert_cmpint (g_output_stream_write_finish (f1, result, &error), ==, 13);
   g_assert_no_error (error);
   g_clear_object (&result);

   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 13);

   g_output_stream_write_async (f2, "nopqrstuvwxyz", 13, G_PRIORITY_DEFAULT,
                                NULL, return_result_cb, &result);
   g_main_loop_run (loop);
   g_assert_cmpint (g_output_stream_write_finish (f2, result, &error), ==, 13);
   g_assert_no_error (error);
   g_clear_object (&result);

   g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 26);

   g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 26);
   g_output_stream_write (base, "\0", 1, NULL, &error);
   g_assert_no_error (error);
   g_assert_cmpstr (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (base)), ==, "abcdefghijklmnopqrstuvwxyz");


   g_assert (!g_output_stream_is_closed (base));
   g_assert (!g_output_stream_is_closed (f1));
   g_assert (!g_output_stream_is_closed (f2));

   expected_obj = f1;
   expected_data = g_malloc (20);
   callback_happened = FALSE;
   g_output_stream_close_async (f1, 0, NULL, out_cb, expected_data);

   g_assert (callback_happened == FALSE);
   g_main_loop_run (loop);
   g_assert (callback_happened == TRUE);

   g_assert (!g_output_stream_is_closed (base));
   g_assert (!g_output_stream_is_closed (f2));
   g_free (expected_data);
   g_object_unref (f1);
   g_assert (!g_output_stream_is_closed (base));
   g_assert (!g_output_stream_is_closed (f2));

   expected_obj = f2;
   expected_data = g_malloc (20);
   callback_happened = FALSE;
   g_output_stream_close_async (f2, 0, NULL, out_cb, expected_data);

   g_assert (callback_happened == FALSE);
   g_main_loop_run (loop);
   g_assert (callback_happened == TRUE);

   g_assert (g_output_stream_is_closed (base));
   g_assert (g_output_stream_is_closed (f2));
   g_free (expected_data);
   g_object_unref (f2);

   g_assert (g_output_stream_is_closed (base));
   g_object_unref (base);
   g_main_loop_unref (loop);
 }

 int
 main (int argc, char **argv)
 {
   g_test_init (&argc, &argv, NULL);
   g_test_bug_base ("http://bugzilla.gnome.org/");

   g_test_add_func ("/filter-stream/input", test_input_filter);
   g_test_add_func ("/filter-stream/output", test_output_filter);
   g_test_add_func ("/filter-stream/async-input", test_input_async);
   g_test_add_func ("/filter-stream/async-output", test_output_async);

   return g_test_run();
 }
	/*
	* Copyright © 2009 Codethink Limited
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* See the included COPYING file for more information.
	*
	* Author: Ryan Lortie <desrt@desrt.ca>
	*/

	#include <string.h>
	#include <glib/glib.h>
	#include <gio/gio.h>

	/* GFilterInputStream and GFilterOutputStream are abstract, so define
	* minimal subclasses for testing. (This used to use
	* GBufferedInputStream and GBufferedOutputStream, but those have
	* their own test program, and they override some methods, meaning the
	* core filter stream functionality wasn't getting fully tested.)
	*/

	GType test_filter_input_stream_get_type (void);
	GType test_filter_output_stream_get_type (void);

	#define TEST_TYPE_FILTER_INPUT_STREAM (test_filter_input_stream_get_type ())
	#define TEST_FILTER_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TEST_TYPE_FILTER_INPUT_STREAM, TestFilterInputStream))
	#define TEST_TYPE_FILTER_OUTPUT_STREAM (test_filter_output_stream_get_type ())
	#define TEST_FILTER_OUTPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TEST_TYPE_FILTER_OUTPUT_STREAM, TestFilterOutputStream))

	typedef GFilterInputStream TestFilterInputStream;
	typedef GFilterInputStreamClass TestFilterInputStreamClass;
	typedef GFilterOutputStream TestFilterOutputStream;
	typedef GFilterOutputStreamClass TestFilterOutputStreamClass;

	G_DEFINE_TYPE (TestFilterInputStream, test_filter_input_stream, G_TYPE_FILTER_INPUT_STREAM)
	G_DEFINE_TYPE (TestFilterOutputStream, test_filter_output_stream, G_TYPE_FILTER_OUTPUT_STREAM)

	static void
	test_filter_input_stream_init (TestFilterInputStream *stream)
	{
	}

	static void
	test_filter_input_stream_class_init (TestFilterInputStreamClass *klass)
	{
	}

	static void
	test_filter_output_stream_init (TestFilterOutputStream *stream)
	{
	}

	static void
	test_filter_output_stream_class_init (TestFilterOutputStreamClass *klass)
	{
	}

	/* Now the tests */

	static void
	test_input_filter (void)
	{
	GInputStream base, f1, f2, s;
	gboolean close_base;
	gchar buf[1024];
	GError *error = NULL;

	g_test_bug ("568394");
	base = g_memory_input_stream_new_from_data ("abcdefghijk", -1, NULL);
	f1 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
	"base-stream", base,
	"close-base-stream", FALSE,
	NULL);
	f2 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
	"base-stream", base,
	NULL);

	g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f1)) == base);
	g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f2)) == base);

	g_assert (!g_input_stream_is_closed (base));
	g_assert (!g_input_stream_is_closed (f1));
	g_assert (!g_input_stream_is_closed (f2));

	g_object_get (f1,
	"close-base-stream", &close_base,
	"base-stream", &s,
	NULL);
	g_assert (!close_base);
	g_assert (s == base);
	g_object_unref (s);

	g_object_unref (f1);

	g_assert (!g_input_stream_is_closed (base));
	g_assert (!g_input_stream_is_closed (f2));

	g_input_stream_skip (f2, 3, NULL, &error);
	g_assert_no_error (error);

	memset (buf, 0, 1024);
	g_input_stream_read_all (f2, buf, 1024, NULL, NULL, &error);
	g_assert_no_error (error);
	g_assert_cmpstr (buf, ==, "defghijk");

	g_object_unref (f2);

	g_assert (g_input_stream_is_closed (base));

	g_object_unref (base);
	}

	static void
	test_output_filter (void)
	{
	GOutputStream base, f1, *f2;

	base = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
	f1 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
	"base-stream", base,
	"close-base-stream", FALSE,
	NULL);
	f2 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
	"base-stream", base,
	NULL);

	g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f1)) == base);
	g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f2)) == base);

	g_assert (!g_output_stream_is_closed (base));
	g_assert (!g_output_stream_is_closed (f1));
	g_assert (!g_output_stream_is_closed (f2));

	g_object_unref (f1);

	g_assert (!g_output_stream_is_closed (base));
	g_assert (!g_output_stream_is_closed (f2));

	g_object_unref (f2);

	g_assert (g_output_stream_is_closed (base));

	g_object_unref (base);
	}

	gpointer expected_obj;
	gpointer expected_data;
	gboolean callback_happened;
	GMainLoop *loop;

	static void
	return_result_cb (GObject *object,
	GAsyncResult *result,
	gpointer user_data)
	{
	GAsyncResult **ret = user_data;

	*ret = g_object_ref (result);
	g_main_loop_quit (loop);
	}

	static void
	in_cb (GObject *object,
	GAsyncResult *result,
	gpointer user_data)
	{
	GError *error = NULL;

	g_assert (object == expected_obj);
	g_assert (user_data == expected_data);
	g_assert (callback_happened == FALSE);

	g_input_stream_close_finish (expected_obj, result, &error);
	g_assert (error == NULL);

	callback_happened = TRUE;
	g_main_loop_quit (loop);
	}

	static void
	test_input_async (void)
	{
	GInputStream base, f1, *f2;
	char buf[20];
	GAsyncResult *result = NULL;
	GError *error = NULL;

	loop = g_main_loop_new (NULL, FALSE);

	base = g_memory_input_stream_new_from_data ("abcdefghijklmnopqrstuvwxyz", -1, NULL);
	f1 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
	"base-stream", base,
	"close-base-stream", FALSE,
	NULL);
	f2 = g_object_new (TEST_TYPE_FILTER_INPUT_STREAM,
	"base-stream", base,
	NULL);

	g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f1)) == base);
	g_assert (g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (f2)) == base);


	memset (buf, 0, sizeof (buf));
	g_input_stream_read_async (f1, buf, 10, G_PRIORITY_DEFAULT,
	NULL, return_result_cb, &result);
	g_main_loop_run (loop);
	g_assert_cmpint (g_input_stream_read_finish (f1, result, &error), ==, 10);
	g_assert_cmpstr (buf, ==, "abcdefghij");
	g_assert_no_error (error);
	g_clear_object (&result);

	g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 10);

	g_input_stream_skip_async (f2, 10, G_PRIORITY_DEFAULT,
	NULL, return_result_cb, &result);
	g_main_loop_run (loop);
	g_assert_cmpint (g_input_stream_skip_finish (f2, result, &error), ==, 10);
	g_assert_no_error (error);
	g_clear_object (&result);

	g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 20);

	memset (buf, 0, sizeof (buf));
	g_input_stream_read_async (f1, buf, 10, G_PRIORITY_DEFAULT,
	NULL, return_result_cb, &result);
	g_main_loop_run (loop);
	g_assert_cmpint (g_input_stream_read_finish (f1, result, &error), ==, 6);
	g_assert_cmpstr (buf, ==, "uvwxyz");
	g_assert_no_error (error);
	g_clear_object (&result);

	g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 26);


	g_assert (!g_input_stream_is_closed (base));
	g_assert (!g_input_stream_is_closed (f1));
	g_assert (!g_input_stream_is_closed (f2));

	expected_obj = f1;
	expected_data = g_malloc (20);
	callback_happened = FALSE;
	g_input_stream_close_async (f1, 0, NULL, in_cb, expected_data);

	g_assert (callback_happened == FALSE);
	g_main_loop_run (loop);
	g_assert (callback_happened == TRUE);

	g_assert (!g_input_stream_is_closed (base));
	g_assert (!g_input_stream_is_closed (f2));
	g_free (expected_data);
	g_object_unref (f1);
	g_assert (!g_input_stream_is_closed (base));
	g_assert (!g_input_stream_is_closed (f2));

	expected_obj = f2;
	expected_data = g_malloc (20);
	callback_happened = FALSE;
	g_input_stream_close_async (f2, 0, NULL, in_cb, expected_data);

	g_assert (callback_happened == FALSE);
	g_main_loop_run (loop);
	g_assert (callback_happened == TRUE);

	g_assert (g_input_stream_is_closed (base));
	g_assert (g_input_stream_is_closed (f2));
	g_free (expected_data);
	g_object_unref (f2);

	g_assert (g_input_stream_is_closed (base));
	g_object_unref (base);
	g_main_loop_unref (loop);
	}

	static void
	out_cb (GObject *object,
	GAsyncResult *result,
	gpointer user_data)
	{
	GError *error = NULL;

	g_assert (object == expected_obj);
	g_assert (user_data == expected_data);
	g_assert (callback_happened == FALSE);

	g_output_stream_close_finish (expected_obj, result, &error);
	g_assert (error == NULL);

	callback_happened = TRUE;
	g_main_loop_quit (loop);
	}

	static void
	test_output_async (void)
	{
	GOutputStream base, f1, *f2;
	GAsyncResult *result = NULL;
	GError *error = NULL;

	loop = g_main_loop_new (NULL, FALSE);

	base = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
	f1 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
	"base-stream", base,
	"close-base-stream", FALSE,
	NULL);
	f2 = g_object_new (TEST_TYPE_FILTER_OUTPUT_STREAM,
	"base-stream", base,
	NULL);

	g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f1)) == base);
	g_assert (g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (f2)) == base);


	g_output_stream_write_async (f1, "abcdefghijklm", 13, G_PRIORITY_DEFAULT,
	NULL, return_result_cb, &result);
	g_main_loop_run (loop);
	g_assert_cmpint (g_output_stream_write_finish (f1, result, &error), ==, 13);
	g_assert_no_error (error);
	g_clear_object (&result);

	g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 13);

	g_output_stream_write_async (f2, "nopqrstuvwxyz", 13, G_PRIORITY_DEFAULT,
	NULL, return_result_cb, &result);
	g_main_loop_run (loop);
	g_assert_cmpint (g_output_stream_write_finish (f2, result, &error), ==, 13);
	g_assert_no_error (error);
	g_clear_object (&result);

	g_assert_cmpint (g_seekable_tell (G_SEEKABLE (base)), ==, 26);

	g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 26);
	g_output_stream_write (base, "\0", 1, NULL, &error);
	g_assert_no_error (error);
	g_assert_cmpstr (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (base)), ==, "abcdefghijklmnopqrstuvwxyz");


	g_assert (!g_output_stream_is_closed (base));
	g_assert (!g_output_stream_is_closed (f1));
	g_assert (!g_output_stream_is_closed (f2));

	expected_obj = f1;
	expected_data = g_malloc (20);
	callback_happened = FALSE;
	g_output_stream_close_async (f1, 0, NULL, out_cb, expected_data);

	g_assert (callback_happened == FALSE);
	g_main_loop_run (loop);
	g_assert (callback_happened == TRUE);

	g_assert (!g_output_stream_is_closed (base));
	g_assert (!g_output_stream_is_closed (f2));
	g_free (expected_data);
	g_object_unref (f1);
	g_assert (!g_output_stream_is_closed (base));
	g_assert (!g_output_stream_is_closed (f2));

	expected_obj = f2;
	expected_data = g_malloc (20);
	callback_happened = FALSE;
	g_output_stream_close_async (f2, 0, NULL, out_cb, expected_data);

	g_assert (callback_happened == FALSE);
	g_main_loop_run (loop);
	g_assert (callback_happened == TRUE);

	g_assert (g_output_stream_is_closed (base));
	g_assert (g_output_stream_is_closed (f2));
	g_free (expected_data);
	g_object_unref (f2);

	g_assert (g_output_stream_is_closed (base));
	g_object_unref (base);
	g_main_loop_unref (loop);
	}

	int
	main (int argc, char **argv)
	{
	g_test_init (&argc, &argv, NULL);
	g_test_bug_base ("http://bugzilla.gnome.org/");

	g_test_add_func ("/filter-stream/input", test_input_filter);
	g_test_add_func ("/filter-stream/output", test_output_filter);
	g_test_add_func ("/filter-stream/async-input", test_input_async);
	g_test_add_func ("/filter-stream/async-output", test_output_async);

	return g_test_run();
	}