From 99e80d6ecf06cc60f2734f87bc974bd9479ba139 Mon Sep 17 00:00:00 2001 From: Not Zed Date: Fri, 24 Nov 2000 03:18:20 +0000 Subject: Add tests. 2000-11-24 Not Zed * Makefile.am (SUBDIRS): Add tests. * camel-mime-filter-basic.c (filter): Well, I'll add the extra bytes here too, lathough not strictly needed, might save a re-malloc when we get to complete(). * camel-mime-filter-charset.c (filter): Make sure we have room if we only convert very short data. (complete): and here too. * tests/Makefile.am: Initial test harness & tests. Requires gcc for this. * camel-internet-address.c (d): Turn off debug. * camel-charset-map.c (camel_charset_step): Oops, & masks for set intersection, not | them. Dunno how this got even close to working. 2000-11-23 Not Zed * camel-mime-filter-basic.c (filter): For base64 encoding, the output size for 0, 1, or 2 bytes of input can exceed input*2, so make sure we account for that as well. (complete): And here. (complete): Similarly for qp encoding, if we have a trailing space, we need some extra bytes (not needed for 'filter()', as any such bytes are stored in state/save). * camel-mime-utils.c (quoted_decode_step): Removed fixme not required. (quoted_encode_close): Dont append a trailing afterall. Otherwise a pass through the encode/decode will grow the message each time. svn path=/trunk/; revision=6656 --- camel/ChangeLog | 35 ++++ camel/Makefile.am | 2 +- camel/camel-charset-map.c | 2 +- camel/camel-internet-address.c | 2 +- camel/camel-mime-filter-basic.c | 18 +- camel/camel-mime-filter-charset.c | 4 +- camel/camel-mime-part-utils.c | 4 +- camel/camel-mime-utils.c | 10 +- camel/tests/Makefile.am | 3 + camel/tests/data/gendoc.pl | 65 ++++++++ camel/tests/data/genline.pl | 72 ++++++++ camel/tests/lib/Makefile.am | 10 ++ camel/tests/lib/addresses.c | 51 ++++++ camel/tests/lib/addresses.h | 5 + camel/tests/lib/camel-test.c | 240 +++++++++++++++++++++++++++ camel/tests/lib/camel-test.h | 52 ++++++ camel/tests/lib/messages.c | 145 ++++++++++++++++ camel/tests/lib/messages.h | 12 ++ camel/tests/message/Makefile.am | 22 +++ camel/tests/message/test1.c | 189 +++++++++++++++++++++ camel/tests/message/test2.c | 337 ++++++++++++++++++++++++++++++++++++++ 21 files changed, 1264 insertions(+), 16 deletions(-) create mode 100644 camel/tests/Makefile.am create mode 100755 camel/tests/data/gendoc.pl create mode 100755 camel/tests/data/genline.pl create mode 100644 camel/tests/lib/Makefile.am create mode 100644 camel/tests/lib/addresses.c create mode 100644 camel/tests/lib/addresses.h create mode 100644 camel/tests/lib/camel-test.c create mode 100644 camel/tests/lib/camel-test.h create mode 100644 camel/tests/lib/messages.c create mode 100644 camel/tests/lib/messages.h create mode 100644 camel/tests/message/Makefile.am create mode 100644 camel/tests/message/test1.c create mode 100644 camel/tests/message/test2.c diff --git a/camel/ChangeLog b/camel/ChangeLog index e80ff42226..6e8fb27fd8 100644 --- a/camel/ChangeLog +++ b/camel/ChangeLog @@ -1,3 +1,38 @@ +2000-11-24 Not Zed + + * Makefile.am (SUBDIRS): Add tests. + + * camel-mime-filter-basic.c (filter): Well, I'll add the extra + bytes here too, lathough not strictly needed, might save a + re-malloc when we get to complete(). + + * camel-mime-filter-charset.c (filter): Make sure we have room if + we only convert very short data. + (complete): and here too. + + * tests/Makefile.am: Initial test harness & tests. Requires gcc + for this. + + * camel-internet-address.c (d): Turn off debug. + + * camel-charset-map.c (camel_charset_step): Oops, & masks for set + intersection, not | them. Dunno how this got even close to + working. + +2000-11-23 Not Zed + + * camel-mime-filter-basic.c (filter): For base64 encoding, the + output size for 0, 1, or 2 bytes of input can exceed input*2, so + make sure we account for that as well. + (complete): And here. + (complete): Similarly for qp encoding, if we have a trailing + space, we need some extra bytes (not needed for 'filter()', as any + such bytes are stored in state/save). + + * camel-mime-utils.c (quoted_decode_step): Removed fixme not required. + (quoted_encode_close): Dont append a trailing afterall. Otherwise + a pass through the encode/decode will grow the message each time. + 2000-11-22 Radek Doulik * camel-mime-utils.c (header_msgid_generate): check for return diff --git a/camel/Makefile.am b/camel/Makefile.am index a57f1c5fbb..cb2924e467 100644 --- a/camel/Makefile.am +++ b/camel/Makefile.am @@ -1,6 +1,6 @@ ## Process this file with automake to produce Makefile.in -SUBDIRS = providers +SUBDIRS = providers tests libcamelincludedir = $(includedir)/camel providerdir = $(libdir)/evolution/camel-providers/$(VERSION) diff --git a/camel/camel-charset-map.c b/camel/camel-charset-map.c index fd18337aae..c8974af936 100644 --- a/camel/camel-charset-map.c +++ b/camel/camel-charset-map.c @@ -231,7 +231,7 @@ camel_charset_step(CamelCharset *c, const char *in, int len) } inptr = newinptr; if (c<=0xffff) { - mask |= charset_mask(c); + mask &= charset_mask(c); if (c>=128 && c<256) level = MAX(level, 1); diff --git a/camel/camel-internet-address.c b/camel/camel-internet-address.c index e93fd581a1..1bcd532625 100644 --- a/camel/camel-internet-address.c +++ b/camel/camel-internet-address.c @@ -23,7 +23,7 @@ #include -#define d(x) x +#define d(x) static int internet_decode (CamelAddress *, const char *raw); static char * internet_encode (CamelAddress *); diff --git a/camel/camel-mime-filter-basic.c b/camel/camel-mime-filter-basic.c index 8dd94e1580..17e667c5ae 100644 --- a/camel/camel-mime-filter-basic.c +++ b/camel/camel-mime-filter-basic.c @@ -98,23 +98,27 @@ complete(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, switch(f->type) { case CAMEL_MIME_FILTER_BASIC_BASE64_ENC: /* wont go to more than 2x size (overly conservative) */ - camel_mime_filter_set_size(mf, len*2, FALSE); + camel_mime_filter_set_size(mf, len*2+6, FALSE); newlen = base64_encode_close(in, len, TRUE, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len*2+6); break; case CAMEL_MIME_FILTER_BASIC_QP_ENC: /* *4 is definetly more than needed ... */ - camel_mime_filter_set_size(mf, len*4, FALSE); + camel_mime_filter_set_size(mf, len*4+4, FALSE); newlen = quoted_encode_close(in, len, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len*4+4); break; case CAMEL_MIME_FILTER_BASIC_BASE64_DEC: /* output can't possibly exceed the input size */ - camel_mime_filter_set_size(mf, len, FALSE); + camel_mime_filter_set_size(mf, len, FALSE); newlen = base64_decode_step(in, len, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len); break; case CAMEL_MIME_FILTER_BASIC_QP_DEC: /* output can't possibly exceed the input size */ camel_mime_filter_set_size(mf, len, FALSE); newlen = quoted_decode_step(in, len, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len); break; default: g_warning("unknown type %d in CamelMimeFilterBasic", f->type); @@ -142,23 +146,27 @@ filter(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, s switch(f->type) { case CAMEL_MIME_FILTER_BASIC_BASE64_ENC: /* wont go to more than 2x size (overly conservative) */ - camel_mime_filter_set_size(mf, len*2, FALSE); + camel_mime_filter_set_size(mf, len*2+6, FALSE); newlen = base64_encode_step(in, len, TRUE, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len*2+6); break; case CAMEL_MIME_FILTER_BASIC_QP_ENC: /* *4 is overly conservative, but will do */ - camel_mime_filter_set_size(mf, len*4, FALSE); + camel_mime_filter_set_size(mf, len*4+4, FALSE); newlen = quoted_encode_step(in, len, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len*4+4); break; case CAMEL_MIME_FILTER_BASIC_BASE64_DEC: /* output can't possibly exceed the input size */ camel_mime_filter_set_size(mf, len, FALSE); newlen = base64_decode_step(in, len, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len); break; case CAMEL_MIME_FILTER_BASIC_QP_DEC: /* output can't possibly exceed the input size */ camel_mime_filter_set_size(mf, len, FALSE); newlen = quoted_decode_step(in, len, mf->outbuf, &f->state, &f->save); + g_assert(newlen <= len); break; default: g_warning("unknown type %d in CamelMimeFilterBasic", f->type); diff --git a/camel/camel-mime-filter-charset.c b/camel/camel-mime-filter-charset.c index 1fc10a1aff..40562dc88d 100644 --- a/camel/camel-mime-filter-charset.c +++ b/camel/camel-mime-filter-charset.c @@ -96,7 +96,7 @@ complete(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, /* FIXME: there's probably a safer way to size this ...? */ /* We could always resize if we run out of room in outbuf (but it'd be nice not to have to) */ - camel_mime_filter_set_size(mf, len*5, FALSE); + camel_mime_filter_set_size(mf, len*5+16, FALSE); inbuf = in; inlen = len; outbuf = mf->outbuf; @@ -160,7 +160,7 @@ filter(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, s } /* FIXME: there's probably a safer way to size this ...? */ - camel_mime_filter_set_size(mf, len*5, FALSE); + camel_mime_filter_set_size(mf, len*5+16, FALSE); inbuf = in; inlen = len; outbuf = mf->outbuf; diff --git a/camel/camel-mime-part-utils.c b/camel/camel-mime-part-utils.c index 778255393e..84cdf25055 100644 --- a/camel/camel-mime-part-utils.c +++ b/camel/camel-mime-part-utils.c @@ -114,7 +114,7 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser start = camel_mime_parser_tell(mp) + seekable_source->bound_start; } while ( camel_mime_parser_step(mp, &buf, &len) != HSCAN_BODY_END ) { - d(printf("appending o/p data: %.*s\n", len, buf)); + d(printf("appending o/p data: %d: %.*s\n", len, len, buf)); if (buffer) { if (buffer->len > 20480 && seekable_source) { /* is this a 'big' message? Yes? We dont want to convert it all then.*/ @@ -132,7 +132,9 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser if (buffer) { CamelStream *mem; + d(printf("Small message part, kept in memory!\n")); + mem = camel_stream_mem_new_with_byte_array(buffer); camel_data_wrapper_construct_from_stream (dw, mem); camel_object_unref ((CamelObject *)mem); diff --git a/camel/camel-mime-utils.c b/camel/camel-mime-utils.c index 4fa150ae2a..238b34156e 100644 --- a/camel/camel-mime-utils.c +++ b/camel/camel-mime-utils.c @@ -285,6 +285,11 @@ base64_encode_close(unsigned char *in, int inlen, gboolean break_lines, unsigned c1 = ((unsigned char *)save)[1]; c2 = ((unsigned char *)save)[2]; + + d(printf("mode = %d\nc1 = %c\nc2 = %c\n", + (int)((char *)save)[0], + (int)((char *)save)[1], + (int)((char *)save)[2])); switch (((char *)save)[0]) { case 2: @@ -560,10 +565,6 @@ quoted_encode_close(unsigned char *in, int len, unsigned char *out, int *state, } } - /* hmm, not sure if this should really be added here, we dont want - to add it to the content, afterall ...? */ - *outptr++ = '\n'; - *save = 0; *state = -1; @@ -677,7 +678,6 @@ quoted_decode_step(unsigned char *in, int len, unsigned char *out, int *savestat case 0: while (inptr) { + if (m/^msgstr \"(.*)\"/) { + $str = $1; + if ($str eq "") { + while () { + if (m/\"(.*)\"/) { + $str .= $1; + } else { + last; + } + } + } + return $str; + } + } + return ""; +} + +$unknown = "x-unknown-1"; + +foreach $name (@ARGV) { + if ($name =~ m@([^/]*).po$@) { + $poname = $1; + + open IN,"<$name"; + + $header = read_msgstr; + if ($header =~ /Content-Type:.*charset=([-a-zA-Z0-9]*)/i) { + $charset = $1; + } else { + $charset = $unknown++; + } + + print "Building $poname.$charset.txt from $name\n"; + + open OUT,"$fmt > $poname.$charset.txt"; + while (!eof(IN)) { + $msg = read_msgstr; + # de-escape + $msg =~ s/\\n/\n/gso; + $msg =~ s/\\t/\t/gso; + $msg =~ s/\\(.)/$1/gso; + print OUT $msg." "; + } + close OUT; + close IN; + } else { + printf("ignoring $name, probably not intended\n"); + } +} + diff --git a/camel/tests/data/genline.pl b/camel/tests/data/genline.pl new file mode 100755 index 0000000000..99ff43c882 --- /dev/null +++ b/camel/tests/data/genline.pl @@ -0,0 +1,72 @@ +#!/usr/bin/perl + +# Generate 'documents' in different encodings, from po files + +if ($#ARGV < 0) { + print "Usage: genline.pl pofile pofile ...\n"; + exit 1; +} + +sub read_msgstr() +{ + my $str = ""; + while () { + if (m/^msgstr \"(.*)\"/) { + $str = $1; + if ($str eq "") { + while () { + if (m/\"(.*)\"/) { + $str .= $1; + } else { + last; + } + } + } + return $str; + } + } + return ""; +} + +$unknown = "x-unknown-1"; +open OUT, ">test-lines.h"; + +print OUT < 60 && length($msg) < 160) { + print OUT "\t{ \"$charset\", \"$msg\" },\n"; + last; + } +# $msg =~ s/\\n/\n/gso; +# $msg =~ s/\\t/\t/gso; +# $msg =~ s/\\(.)/$1/gso; +# print OUT $msg." "; + } + close IN; + } else { + printf("ignoring $name, probably not intended\n"); + } +} + +print OUT "};\n"; +close OUT; diff --git a/camel/tests/lib/Makefile.am b/camel/tests/lib/Makefile.am new file mode 100644 index 0000000000..1fae79671d --- /dev/null +++ b/camel/tests/lib/Makefile.am @@ -0,0 +1,10 @@ + +check_LIBRARIES = libcameltest.a + +libcameltest_a_SOURCES = \ + camel-test.c camel-test.h \ + messages.c messages.h \ + addresses.c addresses.h + + + diff --git a/camel/tests/lib/addresses.c b/camel/tests/lib/addresses.c new file mode 100644 index 0000000000..a97ac5e4f9 --- /dev/null +++ b/camel/tests/lib/addresses.c @@ -0,0 +1,51 @@ + +#include "addresses.h" +#include "camel-test.h" + +void +test_address_compare(CamelInternetAddress *addr, CamelInternetAddress *addr2) +{ + const char *r1, *r2, *a1, *a2; + char *e1, *e2, *f1, *f2; + int j; + + check(camel_address_length(CAMEL_ADDRESS(addr)) == camel_address_length(CAMEL_ADDRESS(addr2))); + for (j=0;j + +/* addresses.c */ +void test_address_compare(CamelInternetAddress *addr, CamelInternetAddress *addr2); diff --git a/camel/tests/lib/camel-test.c b/camel/tests/lib/camel-test.c new file mode 100644 index 0000000000..b60ba1fb34 --- /dev/null +++ b/camel/tests/lib/camel-test.c @@ -0,0 +1,240 @@ + +#include "camel-test.h" + +#include +#include + +struct _stack { + struct _stack *next; + char *what; +}; + +static int setup; +static struct _stack *state; +static struct _stack *nonfatal; +static int ok; + +int camel_test_verbose; + +static void die(int sig) +{ + static indie = 0; + struct _stack *node; + + if (!indie) { + indie = 1; + printf("\n\nReceived fatal signal %d\n", sig); + node = state; + if (node) { + printf("Current action:\n"); + while (node) { + printf("\t%s\n", node->what); + node = node->next; + } + } + } + + _exit(1); +} + +void camel_test_init(int argc, char **argv) +{ + void camel_init(void); + int i; + + setup = 1; + + camel_init(); + + /* yeah, we do need ot thread init, even though camel isn't compiled with enable threads */ + g_thread_init(NULL); + + signal(SIGSEGV, die); + signal(SIGABRT, die); + + /* default, just say what, how well we did, unless fail, then abort */ + camel_test_verbose = 1; + + for (i=0;i 0) { + printf("Test: %s ... ", what); + fflush(stdout); + } +} + +void camel_test_push(const char *what, ...) +{ + struct _stack *node; + va_list ap; + char *text; + + va_start(ap, what); + text = g_strdup_vprintf(what, ap); + va_end(ap); + + if (camel_test_verbose > 3) + printf("Start step: %s\n", text); + + node = g_malloc(sizeof(*node)); + node->what = text; + node->next = state; + state = node; +} + +void camel_test_pull(void) +{ + struct _stack *node; + + g_assert(state); + + if (camel_test_verbose > 3) + printf("Finish step: %s\n", state->what); + + node = state; + state = node->next; + g_free(node->what); + g_free(node); +} + +void camel_test_fail(const char *why, ...) +{ + struct _stack *node; + va_list ap; + char *text; + + va_start(ap, why); + text = g_strdup_vprintf(why, ap); + va_end(ap); + + if ((nonfatal == NULL && camel_test_verbose > 0) + || (nonfatal && camel_test_verbose > 1)) { + printf("Failed: %s\n", text); + } + + g_free(text); + + if ((nonfatal == NULL && camel_test_verbose > 0) + || (nonfatal && camel_test_verbose > 2)) { + node = state; + if (node) { + printf("Current action:\n"); + while (node) { + printf("\t%s\n", node->what); + node = node->next; + } + } + } + + if (nonfatal == NULL) { + exit(1); + } else { + ok=0; + if (camel_test_verbose > 1) { + printf("Known problem (ignored): %s\n", nonfatal->what); + } + } +} + +void camel_test_nonfatal(const char *why, ...) +{ + struct _stack *node; + va_list ap; + char *text; + + va_start(ap, why); + text = g_strdup_vprintf(why, ap); + va_end(ap); + + if (camel_test_verbose>3) + printf("Start nonfatal: %s\n", text); + + node = g_malloc(sizeof(*node)); + node->what = text; + node->next = nonfatal; + nonfatal = node; +} + +/* dont ask me why but the compiler just can't seem to find the prototypes for this */ +void camel_test_fatal() +{ + struct _stack *node; + + g_assert(nonfatal); + + if (camel_test_verbose>3) + printf("Finish nonfatal: %s\n", nonfatal->what); + + node = nonfatal; + nonfatal = node->next; + g_free(node->what); + g_free(node); +} + +void camel_test_end(void) +{ + if (camel_test_verbose > 0) { + if (ok) + printf("Ok\n"); + else + printf("Partial success\n"); + } + + fflush(stdout); +} + + + + +/* compare strings, ignore whitespace though */ +int string_equal(const char *a, const char *b) +{ + const char *ap, *bp; + int cmp; + + ap = a; + bp = b; + + while (*ap && *bp) { + while (*ap == ' ' || *ap == '\n' || *ap == '\t') + ap++; + while (*bp == ' ' || *bp == '\n' || *bp == '\t') + bp++; + + a = ap; + b = bp; + + while (*ap && *ap != ' ' && *ap != '\n' && *ap != '\t') + ap++; + while (*bp && *bp != ' ' && *bp != '\n' && *bp != '\t') + bp++; + + if (ap - a != bp - a + && ap - 1 > 0 + && memcmp(a, b, ap-a) != 0) { + return 0; + } + } + + return 1; +} + diff --git a/camel/tests/lib/camel-test.h b/camel/tests/lib/camel-test.h new file mode 100644 index 0000000000..8d3c94bd00 --- /dev/null +++ b/camel/tests/lib/camel-test.h @@ -0,0 +1,52 @@ + +/* some utilities for testing */ + +#include "config.h" + +#include +#include + +/* perform a check assertion */ +#define check(x) do {if (!(x)) { camel_test_fail("%s", #x); } } while (0) +#define check_msg(x, y, z...) do {if (!(x)) { camel_test_fail("%s\n\t" #y, #x, ##z); } } while (0) + +#define check_count(object, expected) do { \ + if (CAMEL_OBJECT(object)->ref_count != expected) { \ + camel_test_fail("%s->ref_count != %s\n\tref_count = %d", #object, #expected, CAMEL_OBJECT(object)->ref_count); \ + } \ +} while (0) + +#define check_unref(object, expected) do { \ + check_count(object, expected); \ + camel_object_unref(CAMEL_OBJECT(object)); \ + if (expected == 1) { \ + object = NULL; \ + } \ +} while (0) + +#define test_free(mem) (g_free(mem), mem=NULL) + +#define push camel_test_push +#define pull camel_test_pull + +void camel_test_init(int argc, char **argv); + +/* start/finish a new test */ +void camel_test_start(const char *what); +void camel_test_end(void); + +/* start/finish a new test part */ +void camel_test_push(const char *what, ...); +void camel_test_pull(void); + +/* fail a test, with a reason why */ +void camel_test_fail(const char *why, ...); + +/* Set whether a failed test quits. May be nested, but must be called in nonfatal/fatal pairs */ +void camel_test_nonfatal(const char *why, ...); +void camel_test_fatal(); + + +/* utility functions */ +/* compare strings, ignore whitespace though */ +int string_equal(const char *a, const char *b); diff --git a/camel/tests/lib/messages.c b/camel/tests/lib/messages.c new file mode 100644 index 0000000000..e2e447d97c --- /dev/null +++ b/camel/tests/lib/messages.c @@ -0,0 +1,145 @@ + + +#include "messages.h" +#include "camel-test.h" + +#include +#include +#include + +CamelMimeMessage * +test_message_create_simple(void) +{ + CamelMimeMessage *msg; + CamelInternetAddress *addr; + + msg = camel_mime_message_new(); + + addr = camel_internet_address_new(); + camel_internet_address_add(addr, "Michael Zucchi", "zed@nowhere.com"); + camel_mime_message_set_from(msg, addr); + camel_address_remove((CamelAddress *)addr, -1); + camel_internet_address_add(addr, "POSTMASTER", "POSTMASTER@somewhere.net"); + camel_mime_message_set_recipients(msg, CAMEL_RECIPIENT_TYPE_TO, addr); + camel_address_remove((CamelAddress *)addr, -1); + camel_internet_address_add(addr, "Michael Zucchi", "zed@nowhere.com"); + camel_mime_message_set_recipients(msg, CAMEL_RECIPIENT_TYPE_CC, addr); + + check_unref(addr, 1); + + camel_mime_message_set_subject(msg, "Simple message subject"); + camel_mime_message_set_date(msg, time(0), 930); + + return msg; +} + +void +test_message_set_content_simple(CamelMimePart *part, int how, const char *type, const char *text, int len) +{ + CamelStreamMem *content = NULL; + CamelDataWrapper *dw; + static GByteArray *ba; + + switch (how) { + case 0: + camel_mime_part_set_content(part, text, len, type); + break; + case 1: + content = (CamelStreamMem *)camel_stream_mem_new_with_buffer(text, len); + break; + case 2: + content = (CamelStreamMem *)camel_stream_mem_new(); + camel_stream_mem_set_buffer(content, text, len); + break; + case 3: + ba = g_byte_array_new(); + g_byte_array_append(ba, text, len); + + content = (CamelStreamMem *)camel_stream_mem_new_with_byte_array(ba); + ba = NULL; + break; + case 4: + ba = g_byte_array_new(); + g_byte_array_append(ba, text, len); + + content = (CamelStreamMem *)camel_stream_mem_new(); + camel_stream_mem_set_byte_array(content, ba); + + /* ba gets leaked here */ + break; + } + + if (content != 0) { + dw = camel_data_wrapper_new(); + camel_data_wrapper_set_mime_type (dw, type); + + camel_data_wrapper_construct_from_stream(dw, (CamelStream *)content); + camel_medium_set_content_object((CamelMedium *)part, dw); + + check_unref(content, 2); + check_unref(dw, 2); + } +} + +int +test_message_write_file(CamelMimeMessage *msg, const char *name) +{ + CamelStreamFs *file; + int ret; + + file = (CamelStreamFs *)camel_stream_fs_new_with_name(name, O_CREAT|O_WRONLY, 0600); + camel_data_wrapper_write_to_stream((CamelDataWrapper *)msg, (CamelStream *)file); + ret = camel_stream_close((CamelStream *)file); + + check(((CamelObject *)file)->ref_count == 1); + camel_object_unref((CamelObject *)file); + + return ret; +} + +CamelMimeMessage * +test_message_read_file(const char *name) +{ + CamelStreamFs *file; + CamelMimeMessage *msg2; + + file = (CamelStreamFs *)camel_stream_fs_new_with_name(name, O_RDONLY, 0); + msg2 = camel_mime_message_new(); + + camel_data_wrapper_construct_from_stream((CamelDataWrapper *)msg2, (CamelStream *)file); + /* file's refcount may be > 1 if the message is real big */ + check(CAMEL_OBJECT(file)->ref_count >=1); + + return msg2; +} + +int +test_message_compare_content(CamelDataWrapper *dw, const char *text, int len) +{ + CamelStreamMem *content; + + /* sigh, ok, so i len == 0, dw will probably be 0 too + camel_mime_part_set_content is weird like that */ + if (dw == 0 && len == 0) + return 0; + + content = (CamelStreamMem *)camel_stream_mem_new(); + camel_data_wrapper_write_to_stream(dw, (CamelStream *)content); + + check_msg(content->buffer->len == len, "buffer->len = %d, len = %d", content->buffer->len, len); + check_msg(memcmp(content->buffer->data, text, content->buffer->len) == 0, "len = %d", len); + + check_unref(content, 1); + + return 0; +} + +int +test_message_compare_header(CamelMimeMessage *m1, CamelMimeMessage *m2) +{ +} + +int +test_message_compare_messages(CamelMimeMessage *m1, CamelMimeMessage *m2) +{ +} diff --git a/camel/tests/lib/messages.h b/camel/tests/lib/messages.h new file mode 100644 index 0000000000..9cb5758826 --- /dev/null +++ b/camel/tests/lib/messages.h @@ -0,0 +1,12 @@ + +#include + +/* how many ways to set the content contents */ +#define SET_CONTENT_WAYS (5) + +/* messages.c */ +CamelMimeMessage *test_message_create_simple(void); +void test_message_set_content_simple(CamelMimePart *part, int how, const char *type, const char *text, int len); +int test_message_write_file(CamelMimeMessage *msg, const char *name); +CamelMimeMessage *test_message_read_file(const char *name); +int test_message_compare_content(CamelDataWrapper *dw, const char *text, int len); diff --git a/camel/tests/message/Makefile.am b/camel/tests/message/Makefile.am new file mode 100644 index 0000000000..2656a007d9 --- /dev/null +++ b/camel/tests/message/Makefile.am @@ -0,0 +1,22 @@ + +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 + +TESTS = test1 test2 + + + diff --git a/camel/tests/message/test1.c b/camel/tests/message/test1.c new file mode 100644 index 0000000000..681537d269 --- /dev/null +++ b/camel/tests/message/test1.c @@ -0,0 +1,189 @@ +/* + test1.c + + Create a message, save it. + + Retrieve message, compare content. + + + Operations: + writing/loading from different types of streams + reading/writing different content + reading/writing different encodings + reading/writing different charsets + + Just testing streams: + different stream types + different file ops + seek, eof, etc. +*/ + +#include "camel-test.h" +#include "messages.h" + +/* for stat */ +#include +#include + +#include +#include +#include + +struct _text { + char *text; + int len; +}; + +#define MAX_TEXTS (14) +struct _text texts[MAX_TEXTS]; + +static void +setup(void) +{ + int i, j; + char *p; + + /* setup various edge and other general cases */ + texts[0].text = ""; + texts[0].len = 0; + texts[1].text = ""; + texts[1].len = 1; + texts[2].text = "\n"; + texts[2].len = 1; + texts[3].text = "A"; + texts[3].len = 1; + texts[4].text = "This is a test.\n."; + texts[4].len = strlen(texts[4].text); + texts[5].text = "This is a test.\n\n.\n"; + texts[5].len = strlen(texts[5].text); + texts[6].text = g_malloc0(1024); + texts[6].len = 1024; + texts[7].text = g_malloc0(102400); + texts[7].len = 102400; + texts[8].text = g_malloc(1024); + memset(texts[8].text, '\n', 1024); + texts[8].len = 1024; + texts[9].text = g_malloc(102400); + memset(texts[9].text, '\n', 102400); + texts[9].len = 102400; + texts[10].text = g_malloc(1024); + memset(texts[10].text, ' ', 1024); + texts[10].len = 1024; + texts[11].text = g_malloc(102400); + memset(texts[11].text, ' ', 102400); + texts[11].len = 102400; + + srand(42); + p = texts[12].text = g_malloc(1024); + for (i=0;i<1024;i++) { + j = rand(); + if (j +#include + +#include + +#include +#include + +/* a bunch of test strings in different encodings, just taken from gnome-core po files */ +/* see data/genline.pl */ +struct _l { + char *type; + char *line; +} test_lines[] = { + /* FIXME: for now, remove the types libunicode doesn't know about, this is tricky to fix */ + /* And at best, all we could do is translate it to X-Unknown, or something */ + /*{ "windows-1251", "Åäèí àïëåò íå îòãîâàðÿ íà çàÿâêà çà çàïèñ.\nÄà ãî ïðåìàõíà ëè èëè äà ïî÷àêàì?" },*/ + { "iso-8859-1", "Omple les miniatures de la finestra amb contingut de la pantalla" }, + { "ISO-8859-2", "Správce oken hýbe s okrajem okna (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "ISO-8859-1", "Vindueshåndtering flytter dekorationsvindue istedet (AfterStep, Enlightenment, FVWM, IceWM, Sawfish)" }, + { "ISO-8859-1", "Vorschaubilder der Fenster mit dem Bildschirminhalt ausfüllen" }, + { "iso-8859-7", "ÅìöÜíéóç åñãáóéþí ðïõ äå öáßíïíôáé óôç ëßóôá ðáñáèýñùí (ÐÁÑÁÊÁÌØÇ-ËÉÓÔÁÐÁÑÁÈÕÑÙÍ)" }, + { "iso-8859-1", "You've chosen to disable the startup hint. To re-enable it, choose \"Startup Hint\" in the GNOME Control Centre" }, + { "iso-8859-1", "El aplique de reloj muestra en su panel la fecha y la hora de forma simple y ligero " }, + { "iso-8859-1", "Applet ei vasta salvestuskäsule. Kas peaks ta niisama sulgema, või veel ootama?" }, + { "iso-8859-1", "Lehio kudeatzaileak lehioaren dekorazaioa mugiarazten (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "iso-8859-15", "Näytä sovellukset, joiden ikkunoista on näkyvillä vain otsikkopalkki" }, + { "ISO-8859-1", "Afficher les tâches qui ne sont pas dans la liste des fenêtres" }, + { "iso-8859-1", "Níl applet ag tabhair freagra ar iarratas sábháil. Bain amach an applet nó lean ar fánacht?" }, + { "iso-8859-1", "Amosa-las tarefas agochadas da lista de fiestras (SKIP-WINLIST)" }, + { "iso-8859-2", "Az ablakkezelõ a dekorációt mozgassa az ablak helyett (AfterStep, Enlightenment, FVWM, IceWM, SawMill)" }, + { "iso-8859-1", "Riempi la finestra delle anteprime con il contenuto dello schermo" }, + { "euc-jp", "¥¦¥¤¥ó¥É¥¦¥Þ¥Í¡¼¥¸¥ã¤Ï¾þ¤ê¥¦¥¤¥ó¥É¥¦¤òÆ°¤«¤¹ (AfterStep, Enlightenment, FVWM, IceWM, Sawfish)" }, + { "euc-kr", "â °ü¸®ÀÚ°¡ ²Ù¹Î â ´ë½Å À̵¿ (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "iso-8859-13", "Priedas neatsakinëja á praðymà iðsisaugoti. Paðalinti priedà ar laukti toliau?" }, + { "iso-8859-1", "Window manager verplaatst dekoratie (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "iso-8859-1", "Vindushåndtereren flytter dekorasjonsvinduet i stedet (AfterStep, Enlightenment, FVWM, IceWM, Sawfish)" }, + { "iso-8859-2", "Przemieszczanie dekoracji zamiast okna (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "iso-8859-1", "Este programa é responsável por executar outras aplicações, embeber pequenos applets, a paz no mundo e crashes aleatórios do X." }, + { "iso-8859-1", "Mostrar tarefas que se escondem da lista de janelas (SKIP-WINLIST)" }, + { "koi8-r", "÷ÙÓÏÔÁ ÒÁÂÏÞÅÇÏ ÓÔÏÌÁ × ÐÅÒÅËÌÀÞÁÔÅÌÅ ÓÏ×ÐÁÄÁÅÔ Ó ×ÙÓÏÔÏÊ ÐÁÎÅÌÉ" }, + { "iso-8859-2", "Správca okien presúva okraje okien (AfterStep, Enlightenment, FVWM, IceWM, Sawfish)" }, + { "iso-8859-2", "Ka¾i posle, ki se skrivajo pred upravljalnik oken (SKIP-WINLIST)" }, + { "iso-8859-5", "Window ÜÕÝÐÔ×ÕàØ ßÞÜÕàÐ ÔÕÚÞàÐæØÞÝØ ßàÞ×Þà ãÜÕáâÞ âÞÓa (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "iso-8859-2", "Window menadzeri pomera dekoracioni prozor umesto toga (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, + { "iso-8859-1", "Fönsterhanteraren flyttar dekorationsfönstret istället (AfterStep, Enlightenment, FVWM, IceWM, Sawfish)" }, + /*{ "TSCII", "À½¢ì¸¼î-ºð¼¸ò¾¢ø À¡÷ì¸ ÓÊ¡¾ À½¢ì¸¼í¸¨Ç ¸¡Á¢ (À½¢ì¸¼î-ºð¼¸õ-¾Å¢÷)" },*/ + { "iso-8859-9", "Kaydetme isteðine bir uygulak cevap vermiyor . Uygulaðý sileyim mi , yoksa bekleyeyim mi ?" }, + { "koi8-u", "ðÅÒÅͦÝÅÎÎÑ ÄÅËÏÒÁæ§ ÚÁͦÓÔØ ×¦ËÎÁ (AfterStep, Enlightenment, FVWM, IceWM, Sawfish)" }, + { "iso-8859-1", "Cwand on scriftôr est bodjî foû, li scriftôr èt totes les apliketes å dvins sont pierdowes. Bodjî ci scriftôr chal?" }, + { "gb2312", "ǨÒƵ½×°Êδ°¿Ú¹ÜÀí³ÌÐò(AfterStep, Enlightenment, FVWM, IceWM, SawMill)" }, + { "big5", "µøµ¡ºÞ²zªÌ¥u²¾°Ê¸Ë¹¢µøµ¡ (AfterStep, Enlightenment, FVWM, IceWM, Sawmill)" }, +}; + +static char *convert(const char *in, const char *from, const char *to) +{ + unicode_iconv_t ic = unicode_iconv_open(to, from); + char *out, *outp; + const char *inp; + int inlen, outlen; + + if (ic == (unicode_iconv_t)-1) + return g_strdup(in); + + inlen = strlen(in); + outlen = inlen*5 + 16; + + outp = out = g_malloc(outlen); + inp = in; + + if (unicode_iconv(ic, &inp, &inlen, &outp, &outlen) == -1) { + test_free(out); + unicode_iconv_close(ic); + return g_strdup(in); + } + + if (unicode_iconv(ic, NULL, 0, &outp, &outlen) == -1) { + test_free(out); + unicode_iconv_close(ic); + return g_strdup(in); + } + + unicode_iconv_close(ic); + + *outp = 0; + +#if 0 + /* lets see if we can convert back again? */ + { + char *nout, *noutp; + unicode_iconv_t ic = unicode_iconv_open(from, to); + + inp = out; + inlen = strlen(out); + outlen = inlen*5 + 16; + noutp = nout = g_malloc(outlen); + if (unicode_iconv(ic, &inp, &inlen, &noutp, &outlen) == -1 + || unicode_iconv(ic, NULL, 0, &noutp, &outlen) == -1) { + g_warning("Cannot convert '%s' \n from %s to %s: %s\n", in, to, from, strerror(errno)); + } + unicode_iconv_close(ic); + } + + /* and lets see what camel thinks out optimal charset is */ + { + printf("Camel thinks the best encoding of '%s' is %s, although we converted from %s\n", + in, camel_charset_best(out, strlen(out)), from); + } +#endif + + return out; +} + +#define to_utf8(in, type) convert(in, type, "utf-8") +#define from_utf8(in, type) convert(in, "utf-8", type) + +#define ARRAY_LEN(x) (sizeof(x)/sizeof(x[0])) + +int main(int argc, char **argv) +{ + int i; + CamelInternetAddress *addr, *addr2; + char *name; + char *charset; + const char *real, *where; + char *enc, *enc2, *format, *format2; + + camel_test_init(argc, argv); + + camel_test_start("CamelInternetAddress, basics"); + + addr = camel_internet_address_new(); + + push("Test blank address"); + check(camel_address_length(CAMEL_ADDRESS(addr)) == 0); + check(camel_internet_address_get(addr, 0, &real, &where) == FALSE); + pull(); + + push("Test blank clone"); + addr2 = CAMEL_INTERNET_ADDRESS(camel_address_new_clone(CAMEL_ADDRESS(addr))); + test_address_compare(addr, addr2); + check_unref(addr2, 1); + pull(); + + push("Test add 1"); + camel_internet_address_add(addr, "Zed", "nowhere@here.com.au"); + check(camel_address_length(CAMEL_ADDRESS(addr)) == 1); + check(camel_internet_address_get(addr, 0, &real, &where) == TRUE); + check_msg(string_equal("Zed", real), "real = '%s'", real); + check(strcmp(where, "nowhere@here.com.au") == 0); + pull(); + + push("Test clone 1"); + addr2 = CAMEL_INTERNET_ADDRESS(camel_address_new_clone(CAMEL_ADDRESS(addr))); + test_address_compare(addr, addr2); + check_unref(addr2, 1); + pull(); + + push("Test add many"); + for (i=1;i<10;i++) { + char name[16], a[32]; + sprintf(name, "Zed %d", i); + sprintf(a, "nowhere@here-%d.com.au", i); + camel_internet_address_add(addr, name, a); + check(camel_address_length(CAMEL_ADDRESS(addr)) == i+1); + check(camel_internet_address_get(addr, i, &real, &where) == TRUE); + check_msg(string_equal(name, real), "name = '%s' real = '%s'", name, real); + check(strcmp(where, a) == 0); + } + pull(); + + /* put a few of these in to make it look like its doing something impressive ... :) */ + camel_test_end(); + camel_test_start("CamelInternetAddress, search"); + + push("Test search"); + camel_test_nonfatal("Address comparisons should ignore whitespace??"); + check(camel_internet_address_find_name(addr, "Zed 1", &where) == 1); + check(camel_internet_address_find_name(addr, "Zed 9", &where) == 9); + check(camel_internet_address_find_name(addr, "Zed", &where) == 0); + check(camel_internet_address_find_name(addr, " Zed", &where) == 0); + check(camel_internet_address_find_name(addr, "Zed ", &where) == 0); + check(camel_internet_address_find_name(addr, " Zed ", &where) == 0); + check(camel_internet_address_find_name(addr, "Zed 20", &where) == -1); + check(camel_internet_address_find_name(addr, "", &where) == -1); + /* interface dont handle nulls :) */ + /*check(camel_internet_address_find_name(addr, NULL, &where) == -1);*/ + + check(camel_internet_address_find_address(addr, "nowhere@here-1.com.au", &where) == 1); + check(camel_internet_address_find_address(addr, "nowhere@here-1 . com.au", &where) == 1); + check(camel_internet_address_find_address(addr, "nowhere@here-2 .com.au ", &where) == 2); + check(camel_internet_address_find_address(addr, " nowhere @here-3.com.au", &where) == 3); + check(camel_internet_address_find_address(addr, "nowhere@here-20.com.au ", &where) == -1); + check(camel_internet_address_find_address(addr, "", &where) == -1); + /*check(camel_internet_address_find_address(addr, NULL, &where) == -1);*/ + camel_test_fatal(); + pull(); + + camel_test_end(); + camel_test_start("CamelInternetAddress, copy/cat/clone"); + + push("Test clone many"); + addr2 = CAMEL_INTERNET_ADDRESS(camel_address_new_clone(CAMEL_ADDRESS(addr))); + test_address_compare(addr, addr2); + pull(); + + push("Test remove items"); + camel_address_remove(CAMEL_ADDRESS(addr2), 0); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 9); + camel_address_remove(CAMEL_ADDRESS(addr2), 0); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 8); + camel_address_remove(CAMEL_ADDRESS(addr2), 5); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 7); + camel_address_remove(CAMEL_ADDRESS(addr2), 10); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 7); + camel_address_remove(CAMEL_ADDRESS(addr2), -1); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 0); + check_unref(addr2, 1); + pull(); + + push("Testing copy/cat"); + push("clone + cat"); + addr2 = CAMEL_INTERNET_ADDRESS(camel_address_new_clone(CAMEL_ADDRESS(addr))); + camel_address_cat(CAMEL_ADDRESS(addr2), CAMEL_ADDRESS(addr)); + check(camel_address_length(CAMEL_ADDRESS(addr)) == 10); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 20); + check_unref(addr2, 1); + pull(); + + push("cat + cat + copy"); + addr2 = camel_internet_address_new(); + camel_address_cat(CAMEL_ADDRESS(addr2), CAMEL_ADDRESS(addr)); + test_address_compare(addr, addr2); + camel_address_cat(CAMEL_ADDRESS(addr2), CAMEL_ADDRESS(addr)); + check(camel_address_length(CAMEL_ADDRESS(addr)) == 10); + check(camel_address_length(CAMEL_ADDRESS(addr2)) == 20); + camel_address_copy(CAMEL_ADDRESS(addr2), CAMEL_ADDRESS(addr)); + test_address_compare(addr, addr2); + check_unref(addr2, 1); + pull(); + + push("copy"); + addr2 = camel_internet_address_new(); + camel_address_copy(CAMEL_ADDRESS(addr2), CAMEL_ADDRESS(addr)); + test_address_compare(addr, addr2); + check_unref(addr2, 1); + pull(); + + pull(); + + check_unref(addr, 1); + + camel_test_end(); + + camel_test_start("CamelInternetAddress, I18N"); + + for (i=0;i