luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-01-12 23:46:17 +01:00
Code Issues Packages Projects Releases Wiki Activity
fcd2f7e639
glib/gio/tests/buffered-output-stream.c
Ryan Lortie fdc5cd8d9f Change semantics of seek on memory output stream 
It is our intention that memory output streams should operate in two
distinct modes, depending on if a realloc function was provided or not.

In the case that we have a realloc function (resizable mode), we want
the stream to behave as if it were a file that started out empty.  In
the case that we don't have a realloc function (fixed-sized mode), we
want the stream to behave as a block device would.

To this end, we introduce two changes in functionality:

 - seeking to SEEK_END on a resizable stream will now seek to the end of
   the valid data region, not to the end of the allocated memory (which
   is really just an implementation detail)

 - seeks past the end of the allocated memory size are now permitted,
   but only on resizable streams.  The next write will grow the buffer
   (inserting zeros between).

Some tweaks to testcases were required in order not to break the build,
which indicates that this is an API break, but it seems unlikely that
anyone will be effected by these changes 'in the real world'.

Updates to documentation and further testcases are in following commits.

Based on a patch from Maciej Piechotka <uzytkownik2@gmail.com>.

https://bugzilla.gnome.org/show_bug.cgi?id=684842
2013-10-23 11:31:27 -04:00

326 lines
13 KiB
C
Raw Blame History

#include <gio/gio.h>
static void
test_write (void)
{
GOutputStream *base;
GOutputStream *out;
GError *error;
const gchar buffer[] = "abcdefghijklmnopqrstuvwxyz";
base = g_memory_output_stream_new (g_malloc0 (20), 20, NULL, g_free);
out = g_buffered_output_stream_new (base);
g_assert_cmpint (g_buffered_output_stream_get_buffer_size (G_BUFFERED_OUTPUT_STREAM (out)), ==, 4096);
g_assert (!g_buffered_output_stream_get_auto_grow (G_BUFFERED_OUTPUT_STREAM (out)));
g_object_set (out, "auto-grow", TRUE, NULL);
g_assert (g_buffered_output_stream_get_auto_grow (G_BUFFERED_OUTPUT_STREAM (out)));
g_object_set (out, "auto-grow", FALSE, NULL);
g_buffered_output_stream_set_buffer_size (G_BUFFERED_OUTPUT_STREAM (out), 16);
g_assert_cmpint (g_buffered_output_stream_get_buffer_size (G_BUFFERED_OUTPUT_STREAM (out)), ==, 16);
error = NULL;
g_assert_cmpint (g_output_stream_write (out, buffer, 10, NULL, &error), ==, 10);
g_assert_no_error (error);
g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 0);
g_assert_cmpint (g_output_stream_write (out, buffer + 10, 10, NULL, &error), ==, 6);
g_assert_no_error (error);
g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 0);
g_assert (g_output_stream_flush (out, NULL, &error));
g_assert_no_error (error);
g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 16);
g_assert_cmpstr (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (base)), ==, "abcdefghijklmnop");
g_object_unref (out);
g_object_unref (base);
}
static void
test_grow (void)
{
GOutputStream *base;
GOutputStream *out;
GError *error;
const gchar buffer[] = "abcdefghijklmnopqrstuvwxyz";
gint size;
gboolean grow;
base = g_memory_output_stream_new (g_malloc0 (30), 30, g_realloc, g_free);
out = g_buffered_output_stream_new_sized (base, 16);
g_buffered_output_stream_set_auto_grow (G_BUFFERED_OUTPUT_STREAM (out), TRUE);
g_object_get (out, "buffer-size", &size, "auto-grow", &grow, NULL);
g_assert_cmpint (size, ==, 16);
g_assert (grow);
g_assert (g_seekable_can_seek (G_SEEKABLE (out)));
error = NULL;
g_assert_cmpint (g_output_stream_write (out, buffer, 10, NULL, &error), ==, 10);
g_assert_no_error (error);
g_assert_cmpint (g_buffered_output_stream_get_buffer_size (G_BUFFERED_OUTPUT_STREAM (out)), ==, 16);
g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 0);
g_assert_cmpint (g_output_stream_write (out, buffer + 10, 10, NULL, &error), ==, 10);
g_assert_no_error (error);
g_assert_cmpint (g_buffered_output_stream_get_buffer_size (G_BUFFERED_OUTPUT_STREAM (out)), >=, 20);
g_assert_cmpint (g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (base)), ==, 0);
g_assert (g_output_stream_flush (out, NULL, &error));
g_assert_no_error (error);
g_assert_cmpstr (g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (base)), ==, "abcdefghijklmnopqrst");
g_object_unref (out);
g_object_unref (base);
}
static void
test_close (void)
{
GOutputStream *base;
GOutputStream *out;
GError *error;
base = g_memory_output_stream_new (g_malloc0 (30), 30, g_realloc, g_free);
out = g_buffered_output_stream_new (base);
g_assert (g_filter_output_stream_get_close_base_stream (G_FILTER_OUTPUT_STREAM (out)));
error = NULL;
g_assert (g_output_stream_close (out, NULL, &error));
g_assert_no_error (error);
g_assert (g_output_stream_is_closed (base));
g_object_unref (out);
g_object_unref (base);
base = g_memory_output_stream_new (g_malloc0 (30), 30, g_realloc, g_free);
out = g_buffered_output_stream_new (base);
g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (out), FALSE);
error = NULL;
g_assert (g_output_stream_close (out, NULL, &error));
g_assert_no_error (error);
g_assert (!g_output_stream_is_closed (base));
g_object_unref (out);
g_object_unref (base);
}
static void
test_seek (void)
{
GMemoryOutputStream *base;
GOutputStream *out;
GSeekable *seekable;
GError *error;
gsize bytes_written;
gboolean ret;
const gchar buffer[] = "abcdefghijklmnopqrstuvwxyz";
base = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (g_malloc0 (30), 30, NULL, g_free));
out = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM (base), 8);
seekable = G_SEEKABLE (out);
error = NULL;
/* Write data */
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 0);
ret = g_output_stream_write_all (out, buffer, 4, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert_cmpint (bytes_written, ==, 4);
g_assert (ret);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 4);
g_assert_cmpint (g_memory_output_stream_get_data_size (base), ==, 0);
/* Forward relative seek */
ret = g_seekable_seek (seekable, 2, G_SEEK_CUR, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 6);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[0]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[1]);
g_assert_cmpint ('c', ==, ((gchar *)g_memory_output_stream_get_data (base))[2]);
g_assert_cmpint ('d', ==, ((gchar *)g_memory_output_stream_get_data (base))[3]);
ret = g_output_stream_write_all (out, buffer, 2, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (bytes_written, ==, 2);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 8);
/* Backward relative seek */
ret = g_seekable_seek (seekable, -4, G_SEEK_CUR, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 4);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[0]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[1]);
g_assert_cmpint ('c', ==, ((gchar *)g_memory_output_stream_get_data (base))[2]);
g_assert_cmpint ('d', ==, ((gchar *)g_memory_output_stream_get_data (base))[3]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[6]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[7]);
ret = g_output_stream_write_all (out, buffer, 2, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (bytes_written, ==, 2);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 6);
/* From start */
ret = g_seekable_seek (seekable, 2, G_SEEK_SET, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 2);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[0]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[1]);
g_assert_cmpint ('c', ==, ((gchar *)g_memory_output_stream_get_data (base))[2]);
g_assert_cmpint ('d', ==, ((gchar *)g_memory_output_stream_get_data (base))[3]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[4]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[5]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[6]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[7]);
ret = g_output_stream_write_all (out, buffer, 2, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (bytes_written, ==, 2);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 4);
/* From end */
ret = g_seekable_seek (seekable, 6 - 30, G_SEEK_END, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 6);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[0]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[1]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[2]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[3]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[4]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[5]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[6]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[7]);
ret = g_output_stream_write_all (out, buffer + 2, 2, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (bytes_written, ==, 2);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 8);
/* Check flush */
ret = g_output_stream_flush (out, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (g_seekable_tell (G_SEEKABLE (out)), ==, 8);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[0]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[1]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[2]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[3]);
g_assert_cmpint ('a', ==, ((gchar *)g_memory_output_stream_get_data (base))[4]);
g_assert_cmpint ('b', ==, ((gchar *)g_memory_output_stream_get_data (base))[5]);
g_assert_cmpint ('c', ==, ((gchar *)g_memory_output_stream_get_data (base))[6]);
g_assert_cmpint ('d', ==, ((gchar *)g_memory_output_stream_get_data (base))[7]);
g_object_unref (out);
g_object_unref (base);
}
static void
test_truncate(void)
{
GMemoryOutputStream *base_stream;
GOutputStream *stream;
GSeekable *seekable;
GError *error;
gsize bytes_written;
guchar *stream_data;
gsize len;
gboolean res;
len = 8;
/* Create objects */
stream_data = g_malloc0 (len);
base_stream = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (stream_data, len, g_realloc, g_free));
stream = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM (base_stream), 8);
seekable = G_SEEKABLE (stream);
g_assert (g_seekable_can_truncate (seekable));
/* Write */
g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, len);
g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 0);
error = NULL;
res = g_output_stream_write_all (stream, "ab", 2, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert (res);
res = g_output_stream_write_all (stream, "cd", 2, &bytes_written, NULL, &error);
g_assert_no_error (error);
g_assert (res);
res = g_output_stream_flush (stream, NULL, &error);
g_assert_no_error (error);
g_assert (res);
g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, len);
g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
g_assert_cmpint (stream_data[0], ==, 'a');
g_assert_cmpint (stream_data[1], ==, 'b');
g_assert_cmpint (stream_data[2], ==, 'c');
g_assert_cmpint (stream_data[3], ==, 'd');
/* Truncate at position */
res = g_seekable_truncate (seekable, 4, NULL, &error);
g_assert_no_error (error);
g_assert (res);
g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, 4);
g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
g_assert_cmpint (stream_data[0], ==, 'a');
g_assert_cmpint (stream_data[1], ==, 'b');
g_assert_cmpint (stream_data[2], ==, 'c');
g_assert_cmpint (stream_data[3], ==, 'd');
/* Truncate beyond position */
res = g_seekable_truncate (seekable, 6, NULL, &error);
g_assert_no_error (error);
g_assert (res);
g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, 6);
g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 4);
g_assert_cmpint (stream_data[0], ==, 'a');
g_assert_cmpint (stream_data[1], ==, 'b');
g_assert_cmpint (stream_data[2], ==, 'c');
g_assert_cmpint (stream_data[3], ==, 'd');
/* Truncate before position */
res = g_seekable_truncate (seekable, 2, NULL, &error);
g_assert_no_error (error);
g_assert (res);
g_assert_cmpint (g_memory_output_stream_get_size (base_stream), ==, 2);
g_assert_cmpint (g_memory_output_stream_get_data_size (base_stream), ==, 2);
g_assert_cmpint (stream_data[0], ==, 'a');
g_assert_cmpint (stream_data[1], ==, 'b');
g_object_unref (stream);
g_object_unref (base_stream);
}
int
main (int argc, char *argv[])
{
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/buffered-output-stream/write", test_write);
g_test_add_func ("/buffered-output-stream/grow", test_grow);
g_test_add_func ("/buffered-output-stream/seek", test_seek);
g_test_add_func ("/buffered-output-stream/truncate", test_truncate);
g_test_add_func ("/filter-output-stream/close", test_close);
return g_test_run ();
}
Reference in New Issue View Git Blame Copy Permalink