stream_flush does make sense for a substream afterall (if you have a

2000-12-05  Not Zed  <NotZed@HelixCode.com>

        * camel-seekable-substream.c (stream_flush): stream_flush does
        make sense for a substream afterall (if you have a stream_write).
        (stream_write): Implement this.
        (stream_seek): Change the STREAM_END behaviour to be more sane.
        if bounded go from the end of the bound, if unbounded, go from the
        end of the parent stream.

        * camel-stream-mem.c (stream_read): Dont return error if reading
        past the end of data, just return 0.

        * camel-stream-fs.c (camel_stream_fs_init): Initialise the stream
        to be unbound.
        (stream_seek): Fix the logic when seeking from the end of an
        unbounded stream.
        (camel_stream_fs_new_with_fd): If the fd is invalid (-1), then
        return NULL immediately.
        (stream_seek): Range check a SEEK_END so it fits within
        bound_start.

2000-12-01  Not Zed  <NotZed@HelixCode.com>

        * tests/lib/folders.c (test_folder_basic): New test to perform
        basic store operations on folders (taken from folders/test1).
        (test_folder_message_ops): Tkane the guts out of folders/test2.

svn path=/trunk/; revision=6790

1 files changed, 104 insertions, 0 deletions

diff --git a/camel/tests/stream/test3.c b/camel/tests/stream/test3.c
new file mode 100644
index 0000000000..b870a7773e
--- /dev/null
+++ b/camel/tests/stream/test3.c
@@ -0,0 +1,104 @@
+/*
+  test ... camelseekablesubstream */
+
+#include "camel-test.h"
+#include "streams.h"
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "camel/camel-stream-mem.h"
+#include "camel/camel-stream-fs.h"
+#include "camel/camel-seekable-substream.h"
+
+#define ARRAY_LEN(x) (sizeof(x)/sizeof(x[0]))
+
+struct {
+	off_t lower, upper;
+} ranges[] = {
+	{ 3, 10241 },
+	{ 0, 1024 },
+	{ 0, 0 },
+	{ 0, 1 },
+	{ 0, 2 },
+	{ 0, 3 },
+	{ 0, 7 },
+	{ 1, 8 },
+	{ 1, 9 },
+	{ 10245, 10300 },
+	{ 0, CAMEL_STREAM_UNBOUND },
+/*	{ 1, CAMEL_STREAM_UNBOUND },
+	{ 2, CAMEL_STREAM_UNBOUND },
+	{ 3, CAMEL_STREAM_UNBOUND },  these take too long to run
+	{ 7, CAMEL_STREAM_UNBOUND },*/
+	{ 10245, CAMEL_STREAM_UNBOUND },
+};
+
+int main(int argc, char **argv)
+{
+	CamelSeekableStream *ss = NULL;
+	int i, j;
+	CamelSeekableSubstream *sus, *sus2;
+
+	camel_test_init(argc, argv);
+
+	camel_test_start("CamelSeekableSubstream, mem backing");
+	for (j=0;j<SEEKABLE_SUBSTREAM_WAYS;j++) {
+		push("testing writing method %d", j);
+		ss = (CamelSeekableStream *)camel_stream_mem_new();
+		check(ss != NULL);
+		for (i=0;i<ARRAY_LEN(ranges);i++) {
+			push("stream subrange %d-%d", ranges[i].lower, ranges[i].upper);
+			sus = (CamelSeekableSubstream *)camel_seekable_substream_new_with_seekable_stream_and_bounds(ss, ranges[i].lower, ranges[i].upper);
+			check(sus != NULL);
+			
+			test_seekable_substream_writepart((CamelStream *)sus, j);
+			test_seekable_substream_readpart((CamelStream *)sus);
+			
+			sus2 = (CamelSeekableSubstream *)camel_seekable_substream_new_with_seekable_stream_and_bounds(ss, ranges[i].lower, ranges[i].upper);
+			check(sus2 != NULL);
+			test_seekable_substream_readpart((CamelStream *)sus2);
+			
+			check_unref(sus, 1);
+			check_unref(sus2, 1);
+			pull();
+		}
+		check_unref(ss, 1);
+		pull();
+	}
+
+	camel_test_end();
+
+	(void)unlink("stream.txt");
+
+	camel_test_start("CamelSeekableSubstream, file backing");
+	for (j=0;j<SEEKABLE_SUBSTREAM_WAYS;j++) {
+		push("testing writing method %d", j);
+		ss = (CamelSeekableStream *)camel_stream_fs_new_with_name("stream.txt", O_RDWR|O_CREAT|O_TRUNC, 0600);
+		check(ss != NULL);
+		for (i=0;i<ARRAY_LEN(ranges);i++) {
+			push("stream subrange %d-%d", ranges[i].lower, ranges[i].upper);
+			sus = (CamelSeekableSubstream *)camel_seekable_substream_new_with_seekable_stream_and_bounds(ss, ranges[i].lower, ranges[i].upper);
+			check(sus != NULL);
+
+			test_seekable_substream_writepart((CamelStream *)sus, j);
+			test_seekable_substream_readpart((CamelStream *)sus);
+
+			sus2 = (CamelSeekableSubstream *)camel_seekable_substream_new_with_seekable_stream_and_bounds(ss, ranges[i].lower, ranges[i].upper);
+			check(sus2 != NULL);
+			test_seekable_substream_readpart((CamelStream *)sus2);
+			
+			check_unref(sus, 1);
+			check_unref(sus2, 1);
+			pull();
+		}
+		check_unref(ss, 1);
+		(void)unlink("stream.txt");
+		pull();
+	}
+
+	camel_test_end();
+
+	return 0;
+}