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, 53 insertions, 0 deletions

diff --git a/camel/tests/stream/test2.c b/camel/tests/stream/test2.c
new file mode 100644
index 0000000000..02ad88e95c
--- /dev/null
+++ b/camel/tests/stream/test2.c
@@ -0,0 +1,53 @@
+/*
+  test ... camelstreammem */
+
+#include "camel-test.h"
+#include "streams.h"
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "camel/camel-stream-mem.h"
+
+int main(int argc, char **argv)
+{
+	CamelSeekableStream *ss = NULL;
+	int i;
+	int fd = -1;
+	struct stat st;
+	int size;
+	char buffer[1024];
+	GByteArray *ba;
+
+	camel_test_init(argc, argv);
+
+	camel_test_start("CamelStream mem, create, seek, read, write, eos");
+	for (i=0;i<3;i++) {
+
+		push("Creating stream using method %d", i);
+		switch(i) {
+		case 0:
+			ss = (CamelSeekableStream *)camel_stream_mem_new();
+			break;
+		case 1:
+			ba = g_byte_array_new();
+			ss = (CamelSeekableStream *)camel_stream_mem_new_with_byte_array(ba);
+			break;
+		case 2:
+			ss = (CamelSeekableStream *)camel_stream_mem_new_with_buffer("", 0);
+			break;
+		}
+		check(ss != NULL);
+
+		test_stream_seekable_writepart(ss);
+		test_stream_seekable_readpart(ss);
+
+		check_unref(ss, 1);
+		pull();
+	}
+
+	camel_test_end();
+
+	return 0;
+}