callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Not Zed
2000-12-05 11:50:32 +00:00
committed by Michael Zucci
parent 90feaa4ad0
commit a8d65409de
11 changed files with 397 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
camel/ChangeLog
View File

@ -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

81
camel/camel-seekable-substream.c
View File

@ -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;
}

11
camel/camel-stream-fs.c
View File

@ -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;

13
camel/camel-stream-mem.c
View File

@ -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;

1
camel/providers/local/camel-local-summary.c
View File

@ -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);

2
camel/tests/Makefile.am
View File

@ -1,4 +1,4 @@
SUBDIRS = lib \
message folder
message folder stream

4
camel/tests/lib/Makefile.am
View File

@ -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

21
camel/tests/stream/Makefile.am Normal file
View File

@ -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

119
camel/tests/stream/test1.c Normal file
View File

@ -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;
}

53
camel/tests/stream/test2.c Normal file
View File

@ -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;
}

104
camel/tests/stream/test3.c Normal file
View File

@ -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;
}