aboutsummaryrefslogtreecommitdiffstats
path: root/camel
diff options
context:
space:
mode:
Diffstat (limited to 'camel')
-rw-r--r--camel/ChangeLog27
-rw-r--r--camel/camel-seekable-substream.c81
-rw-r--r--camel/camel-stream-fs.c11
-rw-r--r--camel/camel-stream-mem.c13
-rw-r--r--camel/providers/local/camel-local-summary.c1
-rw-r--r--camel/tests/Makefile.am2
-rw-r--r--camel/tests/lib/Makefile.am4
-rw-r--r--camel/tests/stream/Makefile.am21
-rw-r--r--camel/tests/stream/test1.c119
-rw-r--r--camel/tests/stream/test2.c53
-rw-r--r--camel/tests/stream/test3.c104
11 files changed, 397 insertions, 39 deletions
diff --git a/camel/ChangeLog b/camel/ChangeLog
index de60e747e3..6e04660b28 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,30 @@
+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.
+
2000-12-04 Jeffrey Stedfast <fejj@helixcode.com>
* providers/smtp/camel-smtp-transport.c (smtp_connect): i18n-ize
diff --git a/camel/camel-seekable-substream.c b/camel/camel-seekable-substream.c
index 9b197f97bd..ad1a01eef6 100644
--- a/camel/camel-seekable-substream.c
+++ b/camel/camel-seekable-substream.c
@@ -132,14 +132,12 @@ camel_seekable_substream_new_with_seekable_stream_and_bounds (CamelSeekableStrea
static gboolean
parent_reset (CamelSeekableSubstream *seekable_substream, CamelSeekableStream *parent)
{
- CamelSeekableStream *seekable_stream =
- CAMEL_SEEKABLE_STREAM (seekable_substream);
+ CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (seekable_substream);
if (camel_seekable_stream_tell (parent) == seekable_stream->position)
return TRUE;
- return camel_seekable_stream_seek (parent, seekable_stream->position, CAMEL_STREAM_SET)
- == seekable_stream->position;
+ return camel_seekable_stream_seek (parent, seekable_stream->position, CAMEL_STREAM_SET) == seekable_stream->position;
}
static int
@@ -147,8 +145,7 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n)
{
CamelSeekableStream *parent;
CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (stream);
- CamelSeekableSubstream *seekable_substream =
- CAMEL_SEEKABLE_SUBSTREAM (stream);
+ CamelSeekableSubstream *seekable_substream = CAMEL_SEEKABLE_SUBSTREAM (stream);
int v;
if (n == 0)
@@ -183,20 +180,47 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n)
static int
stream_write (CamelStream *stream, const char *buffer, unsigned int n)
{
- /* NOT VALID ON SEEKABLE SUBSTREAM */
- /* Well, it's entirely valid, just not implemented */
- g_warning ("CamelSeekableSubstream:: seekable substream doesn't "
- "have a write method yet?\n");
- return -1;
+ CamelSeekableStream *parent;
+ CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM(stream);
+ CamelSeekableSubstream *seekable_substream = CAMEL_SEEKABLE_SUBSTREAM(stream);
+ int v;
+
+ if (n == 0)
+ return 0;
+
+ parent = seekable_substream->parent_stream;
+
+ /* Go to our position in the parent stream. */
+ if (!parent_reset (seekable_substream, parent)) {
+ stream->eos = TRUE;
+ return 0;
+ }
+
+ /* Compute how many bytes should be written. */
+ if (seekable_stream->bound_end != CAMEL_STREAM_UNBOUND)
+ n = MIN (seekable_stream->bound_end - seekable_stream->position, n);
+
+ if (n == 0) {
+ stream->eos = TRUE;
+ return 0;
+ }
+
+ v = camel_stream_write((CamelStream *)parent, buffer, n);
+
+ /* ignore <0 - it's an error, let the caller deal */
+ if (v > 0)
+ seekable_stream->position += v;
+
+ return v;
+
}
static int
stream_flush (CamelStream *stream)
{
- /* NOT VALID ON SEEKABLE SUBSTREAM */
- g_warning ("CamelSeekableSubstream:: seekable substream doesn't "
- "have a flush method\n");
- return -1;
+ CamelSeekableSubstream *sus = (CamelSeekableSubstream *)stream;
+
+ return camel_stream_flush(sus->parent_stream);
}
static int
@@ -209,9 +233,8 @@ stream_close (CamelStream *stream)
static gboolean
eos (CamelStream *stream)
{
- CamelSeekableSubstream *seekable_substream =
- CAMEL_SEEKABLE_SUBSTREAM (stream);
- CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (stream);
+ CamelSeekableSubstream *seekable_substream = CAMEL_SEEKABLE_SUBSTREAM(stream);
+ CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM(stream);
CamelSeekableStream *parent;
gboolean eos;
@@ -235,9 +258,8 @@ static off_t
stream_seek (CamelSeekableStream *seekable_stream, off_t offset,
CamelStreamSeekPolicy policy)
{
- CamelSeekableSubstream *seekable_substream =
- CAMEL_SEEKABLE_SUBSTREAM (seekable_stream);
- CamelStream *stream = CAMEL_STREAM (seekable_stream);
+ CamelSeekableSubstream *seekable_substream = CAMEL_SEEKABLE_SUBSTREAM(seekable_stream);
+ CamelStream *stream = CAMEL_STREAM(seekable_stream);
off_t real_offset = 0;
stream->eos = FALSE;
@@ -252,11 +274,18 @@ stream_seek (CamelSeekableStream *seekable_stream, off_t offset,
break;
case CAMEL_STREAM_END:
- real_offset = camel_seekable_stream_seek (seekable_substream->parent_stream,
- offset,
- CAMEL_STREAM_END);
- if (real_offset == -1)
- return -1;
+ if (seekable_stream->bound_end == CAMEL_STREAM_UNBOUND) {
+ real_offset = camel_seekable_stream_seek(seekable_substream->parent_stream,
+ offset,
+ CAMEL_STREAM_END);
+ if (real_offset != -1) {
+ if (real_offset<seekable_stream->bound_start)
+ real_offset = seekable_stream->bound_start;
+ seekable_stream->position = real_offset;
+ }
+ return real_offset;
+ }
+ real_offset = seekable_stream->bound_end + offset;
break;
}
diff --git a/camel/camel-stream-fs.c b/camel/camel-stream-fs.c
index 17c6b98e08..59082ec531 100644
--- a/camel/camel-stream-fs.c
+++ b/camel/camel-stream-fs.c
@@ -69,6 +69,7 @@ camel_stream_fs_init (gpointer object, gpointer klass)
CamelStreamFs *stream = CAMEL_STREAM_FS (object);
stream->fd = -1;
+ ((CamelSeekableStream *)stream)->bound_end = CAMEL_STREAM_UNBOUND;
}
static void
@@ -114,6 +115,9 @@ camel_stream_fs_new_with_fd (int fd)
CamelStreamFs *stream_fs;
off_t offset;
+ if (fd == -1)
+ return NULL;
+
stream_fs = CAMEL_STREAM_FS (camel_object_new (camel_stream_fs_get_type ()));
stream_fs->fd = fd;
offset = lseek (fd, 0, SEEK_CUR);
@@ -271,10 +275,13 @@ stream_seek (CamelSeekableStream *stream, off_t offset, CamelStreamSeekPolicy po
real = stream->position + offset;
break;
case CAMEL_STREAM_END:
- if (stream->bound_end != CAMEL_STREAM_UNBOUND) {
+ if (stream->bound_end == CAMEL_STREAM_UNBOUND) {
real = lseek(stream_fs->fd, offset, SEEK_END);
- if (real != -1)
+ if (real != -1) {
+ if (real<stream->bound_start)
+ real = stream->bound_start;
stream->position = real;
+ }
return real;
}
real = stream->bound_end + offset;
diff --git a/camel/camel-stream-mem.c b/camel/camel-stream-mem.c
index 0c07a2759f..b9012bcccb 100644
--- a/camel/camel-stream-mem.c
+++ b/camel/camel-stream-mem.c
@@ -163,11 +163,10 @@ stream_read (CamelStream *stream, char *buffer, size_t n)
nread = MIN (n, camel_stream_mem->buffer->len - seekable->position);
if (nread > 0) {
- memcpy (buffer, camel_stream_mem->buffer->data +
- seekable->position, nread);
+ memcpy (buffer, camel_stream_mem->buffer->data + seekable->position, nread);
seekable->position += nread;
} else
- nread = -1;
+ nread = 0;
return nread;
}
@@ -186,12 +185,10 @@ stream_write (CamelStream *stream, const char *buffer, size_t n)
#warning "g_byte_arrays use g_malloc and so are totally unsuitable for this object"
#endif
if (seekable->position == stream_mem->buffer->len) {
- stream_mem->buffer =
- g_byte_array_append (stream_mem->buffer, (const guint8 *)buffer, nwrite);
+ g_byte_array_append(stream_mem->buffer, (const guint8 *)buffer, nwrite);
} else {
- g_byte_array_set_size (stream_mem->buffer,
- nwrite + stream_mem->buffer->len);
- memcpy (stream_mem->buffer->data + seekable->position, buffer, nwrite);
+ g_byte_array_set_size(stream_mem->buffer, nwrite + stream_mem->buffer->len);
+ memcpy(stream_mem->buffer->data + seekable->position, buffer, nwrite);
}
seekable->position += nwrite;
diff --git a/camel/providers/local/camel-local-summary.c b/camel/providers/local/camel-local-summary.c
index 5e47ee35c3..1377ff43a8 100644
--- a/camel/providers/local/camel-local-summary.c
+++ b/camel/providers/local/camel-local-summary.c
@@ -347,7 +347,6 @@ camel_local_summary_write_headers(int fd, struct _header_raw *header, char *xevl
while (header) {
if (strcmp(header->name, "X-Evolution")) {
- printf("writing header: '%s'\n", header->name);
len = fprintf(out, "%s:%s\n", header->name, header->value);
if (len == -1) {
fclose(out);
diff --git a/camel/tests/Makefile.am b/camel/tests/Makefile.am
index 327f75816d..f604cb81a1 100644
--- a/camel/tests/Makefile.am
+++ b/camel/tests/Makefile.am
@@ -1,4 +1,4 @@
SUBDIRS = lib \
- message folder
+ message folder stream
diff --git a/camel/tests/lib/Makefile.am b/camel/tests/lib/Makefile.am
index a87dc59bf6..aef91a1253 100644
--- a/camel/tests/lib/Makefile.am
+++ b/camel/tests/lib/Makefile.am
@@ -7,7 +7,9 @@ libcameltest_a_SOURCES = \
camel-test.c camel-test.h \
messages.c messages.h \
addresses.c addresses.h \
- folders.c folders.h
+ folders.c folders.h \
+ streams.c streams.h
+
diff --git a/camel/tests/stream/Makefile.am b/camel/tests/stream/Makefile.am
new file mode 100644
index 0000000000..d16f8aaa55
--- /dev/null
+++ b/camel/tests/stream/Makefile.am
@@ -0,0 +1,21 @@
+
+INCLUDES = -I$(top_srcdir)/intl -I$(top_srcdir) -I$(top_srcdir)/camel \
+ -I$(includedir) \
+ -I$(top_srcdir)/camel/tests/lib \
+ -DG_LOG_DOMAIN=\"evolution-tests\"
+
+LDADD = \
+ $(top_builddir)/camel/libcamel.la \
+ $(top_builddir)/e-util/libeutil.la \
+ $(top_builddir)/libibex/libibex.la \
+ $(GNOME_LIBDIR) \
+ $(top_builddir)/camel/tests/lib/libcameltest.a \
+ $(GNOMEUI_LIBS) $(INTLLIBS) $(EXTRA_GNOME_LIBS)
+
+check_PROGRAMS = \
+ test1 test2 test3
+
+TESTS = test1 test2 test3
+
+
+
diff --git a/camel/tests/stream/test1.c b/camel/tests/stream/test1.c
new file mode 100644
index 0000000000..452d45274f
--- /dev/null
+++ b/camel/tests/stream/test1.c
@@ -0,0 +1,119 @@
+/*
+ test ... camelstreamfs */
+
+#include "camel-test.h"
+#include "streams.h"
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "camel/camel-stream-fs.h"
+
+int main(int argc, char **argv)
+{
+ CamelSeekableStream *ss = NULL;
+ int i;
+ int fd = -1;
+ struct stat st;
+ int size;
+ char buffer[1024];
+
+ camel_test_init(argc, argv);
+
+ camel_test_start("CamelStream fs, open, seek, read, write, eos");
+ for (i=0;i<2;i++) {
+
+ (void)unlink("stream.txt");
+
+ push("trying to open a nonexistant stream, method %d", i);
+ switch(i) {
+ case 0:
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_name("stream.txt", O_RDWR, 0);
+ break;
+ case 1:
+ fd = open("stream.txt", O_RDWR, 0);
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_fd(fd);
+ break;
+ }
+ check(ss == NULL && errno == ENOENT);
+ check(stat("stream.txt", &st) == -1 && errno == ENOENT);
+ pull();
+
+ push("Creating stream using method %d", i);
+ switch(i) {
+ case 0:
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_name("stream.txt", O_CREAT|O_RDWR|O_TRUNC, 0600);
+ fd = ((CamelStreamFs *)ss)->fd;
+ break;
+ case 1:
+ fd = open("stream.txt", O_CREAT|O_RDWR|O_TRUNC, 0600);
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_fd(fd);
+ break;
+ }
+ check(ss != NULL);
+ check(stat("stream.txt", &st) == 0 && (st.st_mode&0777) == 0600 && S_ISREG(st.st_mode) && st.st_size == 0);
+ pull();
+
+ test_stream_seekable_writepart(ss);
+ test_stream_seekable_readpart(ss);
+
+ push("getting filesize");
+ check(stat("stream.txt", &st) == 0 && (st.st_mode&0777) == 0600 && S_ISREG(st.st_mode));
+ size = st.st_size;
+ pull();
+
+ push("checking close closes");
+ check_unref(ss, 1);
+ check(close(fd) == -1);
+ pull();
+
+ push("re-opening stream");
+ switch(i) {
+ case 0:
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_name("stream.txt", O_RDWR, 0);
+ fd = ((CamelStreamFs *)ss)->fd;
+ break;
+ case 1:
+ fd = open("stream.txt", O_RDWR, 0);
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_fd(fd);
+ break;
+ }
+ check(ss != NULL);
+ check(stat("stream.txt", &st) == 0 && (st.st_mode&0777) == 0600 && S_ISREG(st.st_mode) && st.st_size == size);
+
+ test_stream_seekable_readpart(ss);
+
+ check_unref(ss, 1);
+ check(close(fd) == -1);
+ pull();
+
+ push("re-opening stream with truncate");
+ switch(i) {
+ case 0:
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_name("stream.txt", O_RDWR|O_TRUNC, 0);
+ fd = ((CamelStreamFs *)ss)->fd;
+ break;
+ case 1:
+ fd = open("stream.txt", O_RDWR|O_TRUNC, 0);
+ ss = (CamelSeekableStream *)camel_stream_fs_new_with_fd(fd);
+ break;
+ }
+ check(ss != NULL);
+ check(stat("stream.txt", &st) == 0 && (st.st_mode&0777) == 0600 && S_ISREG(st.st_mode) && st.st_size == 0);
+
+ /* read has to return 0 before eos is set */
+ check(camel_stream_read(CAMEL_STREAM(ss), buffer, 1) == 0);
+ check(camel_stream_eos(CAMEL_STREAM(ss)));
+
+ check_unref(ss, 1);
+ check(close(fd) == -1);
+ pull();
+
+ (void)unlink("stream.txt");
+ }
+
+ camel_test_end();
+
+ return 0;
+}
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;
+}
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;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 17:36:35 +0800