static void test_remove_at (void) { const char *name, *value; GMimeHeaderList *list; GMimeHeader *header; int count; list = header_list_new (); testsuite_check ("remove first header"); try { /* remove the first header */ g_mime_header_list_remove_at (list, 0); /* make sure the first header is now the same as the second original header */ header = g_mime_header_list_get_header_at (list, 0); name = g_mime_header_get_name (header); value = g_mime_header_get_value (header); if (strcmp (initial[1].name, name) != 0 || strcmp (initial[1].value, value) != 0) throw (exception_new ("expected second Received header")); /* make sure that the internal hash table was properly updated */ if (!(header = g_mime_header_list_get_header (list, "Received"))) throw (exception_new ("lookup of Received header failed")); if (!(value = g_mime_header_get_value (header))) throw (exception_new ("getting Received header value failed")); if (strcmp (initial[1].value, value) != 0) throw (exception_new ("expected second Received header value")); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("remove first header: %s", ex->message); } finally; testsuite_check ("remove last header"); try { /* remove the last header */ count = g_mime_header_list_get_count (list); g_mime_header_list_remove_at (list, count - 1); if ((header = g_mime_header_list_get_header (list, "Message-Id")) != NULL) throw (exception_new ("lookup of Message-Id should have failed")); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("remove last header: %s", ex->message); } finally; g_object_unref (list); }
static void test_indexing (void) { const char *name, *value, *raw_value; GMimeHeaderList *list; GMimeHeader *header; int index; size_t len; list = header_list_new (); /* make sure indexing works as expected */ for (index = 0; index < G_N_ELEMENTS (initial); index++) { testsuite_check ("headers[%d]", index); try { if (!(header = g_mime_header_list_get_header_at (list, index))) throw (exception_new ("failed to get header at index")); name = g_mime_header_get_name (header); value = g_mime_header_get_value (header); if (strcmp (initial[index].name, name) != 0 || strcmp (initial[index].value, value) != 0) throw (exception_new ("resulted in unexpected value")); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("null raw value")); len = strlen (raw_value); if (raw_value[len - 1] != '\n') throw (exception_new ("raw value does not end with a \\n")); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("next iter[%d]: %s", index, ex->message); } finally; } /* make sure trying to advance past the last header fails */ testsuite_check ("indexing past end of headers"); try { if (g_mime_header_list_get_header_at (list, index) != NULL) throw (exception_new ("should not have worked")); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("indexing past end of headers: %s", ex->message); } finally; g_object_unref (list); }
static void test_header_formatting (void) { const char *raw_value; GMimeHeaderList *list; GMimeHeader *header; guint i; list = g_mime_header_list_new (g_mime_parser_options_get_default ()); for (i = 0; i < G_N_ELEMENTS (headers); i++) { testsuite_check ("header[%u]", i); try { g_mime_header_list_append (list, headers[i].name, headers[i].value, NULL); header = g_mime_header_list_get_header_at (list, (int) i); raw_value = g_mime_header_get_raw_value (header); if (strcmp (headers[i].raw_value, raw_value) != 0) throw (exception_new ("raw values do not match: %s", raw_value)); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("header[%u] failed: %s", i, ex->message); } finally; } g_object_unref (list); }
static void test_html (const char *datadir, const char *input, const char *output, guint32 citation) { guint32 flags = GMIME_FILTER_HTML_CONVERT_NL | GMIME_FILTER_HTML_CONVERT_SPACES | GMIME_FILTER_HTML_CONVERT_URLS | GMIME_FILTER_HTML_CONVERT_ADDRESSES; const char *what = "GMimeFilterHtml", *mode; GByteArray *expected, *actual; GMimeStream *stream; GMimeFilter *filter; char *path; switch (citation) { case GMIME_FILTER_HTML_BLOCKQUOTE_CITATION: mode = "blockquote"; break; case GMIME_FILTER_HTML_MARK_CITATION: mode = "mark"; break; case GMIME_FILTER_HTML_CITE: mode = "cite"; break; default: mode = "none"; break; } testsuite_check ("%s (%s %s)", what, input, mode); actual = g_byte_array_new (); stream = g_mime_stream_mem_new_with_byte_array (actual); g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE); filter = g_mime_filter_html_new (flags | citation, 0x008888); path = g_build_filename (datadir, input, NULL); pump_data_through_filter (filter, path, stream, TRUE, TRUE); g_mime_filter_reset (filter); g_object_unref (stream); g_object_unref (filter); g_free (path); path = g_build_filename (datadir, output, NULL); expected = read_all_bytes (path, TRUE); g_free (path); if (actual->len != expected->len) { testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u", what, expected->len, actual->len); stream = g_mime_stream_fs_open (output, O_WRONLY | O_CREAT, 0644, NULL); g_mime_stream_write (stream, (const char *) actual->data, actual->len); g_mime_stream_flush (stream); g_object_unref (stream); goto error; } if (memcmp (actual->data, expected->data, actual->len) != 0) { testsuite_check_failed ("%s failed: stream contents do not match", what); goto error; } testsuite_check_passed (); error: g_byte_array_free (expected, TRUE); g_byte_array_free (actual, TRUE); }
static void test_streams (GDir *dir, const char *datadir, const char *filename) { char inpath[256], outpath[256], *p, *q, *o; const char *dent, *d; gint64 start, end; size_t n; guint i; p = g_stpcpy (inpath, datadir); *p++ = G_DIR_SEPARATOR; p = g_stpcpy (p, "input"); *p++ = G_DIR_SEPARATOR; strcpy (p, filename); q = g_stpcpy (outpath, datadir); *q++ = G_DIR_SEPARATOR; q = g_stpcpy (q, "output"); *q++ = G_DIR_SEPARATOR; *q = '\0'; n = strlen (filename); while ((dent = g_dir_read_name (dir))) { if (strncmp (dent, filename, n) != 0 || dent[n] != '_') continue; d = dent + n + 1; if ((start = strtol (d, &o, 10)) < 0 || *o != ',') continue; d = o + 1; if ((((end = strtol (d, &o, 10)) < start) && end != -1) || *o != '\0') continue; strcpy (q, dent); for (i = 0; i < G_N_ELEMENTS (checks); i++) { testsuite_check ("%s on `%s'", checks[i].what, dent); try { if (!checks[i].check (inpath, outpath, dent, start, end)) { testsuite_check_warn ("%s could not open `%s'", checks[i].what, dent); } else { testsuite_check_passed (); } } catch (ex) { testsuite_check_failed ("%s on `%s' failed: %s", checks[i].what, dent, ex->message); } finally; } } g_dir_rewind (dir); }
static void test_gzip (const char *datadir, const char *filename) { char *name = g_strdup_printf ("%s.gz", filename); char *path = g_build_filename (datadir, filename, NULL); const char *what = "GMimeFilterGzip::zip"; GByteArray *actual, *expected; GMimeStream *stream; GMimeFilter *filter; testsuite_check ("%s", what); actual = g_byte_array_new (); stream = g_mime_stream_mem_new_with_byte_array (actual); g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE); filter = g_mime_filter_gzip_new (GMIME_FILTER_GZIP_MODE_ZIP, 9); g_mime_filter_gzip_set_filename ((GMimeFilterGZip *) filter, filename); g_mime_filter_gzip_set_comment ((GMimeFilterGZip *) filter, "This is a comment."); pump_data_through_filter (filter, path, stream, TRUE, TRUE); g_mime_filter_reset (filter); g_object_unref (stream); g_object_unref (filter); g_free (path); path = g_build_filename (datadir, name, NULL); expected = read_all_bytes (path, FALSE); g_free (name); g_free (path); if (actual->len != 1233 && (actual->len != expected->len || memcmp (actual->data, expected->data, actual->len) != 0)) { if (actual->len != expected->len) testsuite_check_failed ("%s failed: streams are not the same length: %u", what, actual->len); else testsuite_check_failed ("%s failed: streams do not match", what); name = g_strdup_printf ("%s.1.gz", filename); path = g_build_filename (datadir, name, NULL); g_free (name); stream = g_mime_stream_fs_open (path, O_WRONLY | O_CREAT | O_TRUNC, 0644, NULL); g_free (path); g_mime_stream_write (stream, (const char *) actual->data, actual->len); g_mime_stream_flush (stream); g_object_unref (stream); } else { testsuite_check_passed (); } g_byte_array_free (expected, TRUE); g_byte_array_free (actual, TRUE); }
static void test_stream_buffer_gets (const char *filename) { GMimeStream *stream, *buffered = NULL; int fd; if ((fd = open (filename, O_RDONLY, 0)) == -1) { v(fprintf (stderr, "failed to open %s", filename)); return; } stream = g_mime_stream_fs_new (fd); testsuite_check ("GMimeStreamBuffer::block gets"); try { g_mime_stream_reset (stream); buffered = g_mime_stream_buffer_new (stream, GMIME_STREAM_BUFFER_BLOCK_READ); test_stream_gets (buffered, filename); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("GMimeStreamBuffer::block gets() failed: %s", ex->message); } finally { g_object_unref (buffered); } testsuite_check ("GMimeStreamBuffer::cache gets"); try { g_mime_stream_reset (stream); buffered = g_mime_stream_buffer_new (stream, GMIME_STREAM_BUFFER_CACHE_READ); test_stream_gets (buffered, filename); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("GMimeStreamBuffer::block gets() failed: %s", ex->message); } finally { g_object_unref (buffered); } g_object_unref (stream); }
static void test_charset_conversion (const char *datadir, const char *base, const char *from, const char *to) { const char *what = "GMimeFilterCharset"; GByteArray *actual, *expected; GMimeStream *stream; GMimeFilter *filter; char *path, *name; testsuite_check ("%s (%s %s -> %s)", what, base, from, to); actual = g_byte_array_new (); stream = g_mime_stream_mem_new_with_byte_array (actual); g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE); filter = g_mime_filter_charset_new (from, to); name = g_strdup_printf ("%s.%s.txt", base, from); path = g_build_filename (datadir, name, NULL); pump_data_through_filter (filter, path, stream, TRUE, TRUE); g_mime_filter_reset (filter); g_object_unref (stream); g_object_unref (filter); g_free (path); g_free (name); name = g_strdup_printf ("%s.%s.txt", base, to); path = g_build_filename (datadir, name, NULL); expected = read_all_bytes (path, TRUE); g_free (path); g_free (name); if (actual->len != expected->len) { testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u", what, expected->len, actual->len); goto error; } if (memcmp (actual->data, expected->data, actual->len) != 0) { testsuite_check_failed ("%s failed: stream contents do not match", what); goto error; } testsuite_check_passed (); error: g_byte_array_free (expected, TRUE); g_byte_array_free (actual, TRUE); }
static void test_enriched (const char *datadir, const char *input, const char *output) { const char *what = "GMimeFilterEnriched"; GByteArray *actual, *expected; GMimeStream *stream; GMimeFilter *filter; char *path; testsuite_check ("%s (%s)", what, input); actual = g_byte_array_new (); stream = g_mime_stream_mem_new_with_byte_array (actual); g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE); filter = g_mime_filter_enriched_new (0); path = g_build_filename (datadir, input, NULL); pump_data_through_filter (filter, path, stream, TRUE, TRUE); g_mime_filter_reset (filter); g_object_unref (stream); g_object_unref (filter); g_free (path); path = g_build_filename (datadir, output, NULL); expected = read_all_bytes (path, TRUE); g_free (path); if (actual->len != expected->len) { testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u", what, expected->len, actual->len); printf ("enriched: -->%.*s<--\n", (int) actual->len, (char *) actual->data); goto error; } if (memcmp (actual->data, expected->data, actual->len) != 0) { testsuite_check_failed ("%s failed: stream contents do not match", what); goto error; } testsuite_check_passed (); error: g_byte_array_free (expected, TRUE); g_byte_array_free (actual, TRUE); }
static void test_windows (const char *datadir, const char *filename, const char *claimed, const char *expected) { const char *what = "GMimeFilterWindows"; GMimeStream *stream; GMimeFilter *filter; const char *actual; char *path; testsuite_check ("%s", what); filter = g_mime_filter_windows_new (claimed); stream = g_mime_stream_null_new (); path = g_build_filename (datadir, filename, NULL); pump_data_through_filter (filter, path, stream, TRUE, TRUE); g_object_unref (stream); g_free (path); actual = g_mime_filter_windows_real_charset ((GMimeFilterWindows *) filter); if (strcmp (expected, actual) != 0) { testsuite_check_failed ("%s failed: charsets do not match: expected=%s; actual=%s", what, expected, actual); goto error; } if (!g_mime_filter_windows_is_windows_charset ((GMimeFilterWindows *) filter)) { testsuite_check_failed ("%s failed: is_windows_charset returned FALSE", what); goto error; } testsuite_check_passed (); error: g_mime_filter_reset (filter); g_object_unref (filter); }
static void test_stream_mem (const char *filename) { /* Note: this also tests g_mime_stream_write_to_stream */ GMimeStream *stream, *fstream; int fd; if ((fd = open (filename, O_RDONLY, 0)) == -1) { v(fprintf (stderr, "failed to open %s: %s\n", filename, g_strerror (errno))); return; } testsuite_start ("GMimeStreamMem"); fstream = g_mime_stream_fs_new (fd); stream = g_mime_stream_mem_new (); testsuite_check ("GMimeStreamMem::read()"); try { if (g_mime_stream_write_to_stream (fstream, stream) == -1) throw (exception_new ("g_mime_stream_write_to_stream() failed")); if (g_mime_stream_length (stream) != g_mime_stream_length (fstream)) throw (exception_new ("stream lengths didn't match")); test_stream_read (stream, filename); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("GMimeStreamMem::read() failed: %s", ex->message); } finally; g_object_unref (fstream); g_object_unref (stream); testsuite_end (); }
int main (int argc, char **argv) { const char *datadir = "data/mbox"; char input[256], output[256], *tmp, *p, *q; GMimeStream *istream, *ostream, *mstream, *pstream; GMimeParser *parser; const char *dent; const char *path; struct stat st; GDir *dir; int i; #ifdef ENABLE_MBOX_MATCH int fd; if (mkdir ("./tmp", 0755) == -1 && errno != EEXIST) return 0; #endif g_mime_init (); testsuite_init (argc, argv); path = datadir; for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { path = argv[i]; break; } } testsuite_start ("Mbox parser"); if (stat (path, &st) == -1) goto exit; if (S_ISDIR (st.st_mode)) { /* automated testsuite */ p = g_stpcpy (input, path); *p++ = G_DIR_SEPARATOR; p = g_stpcpy (p, "input"); if (!(dir = g_dir_open (input, 0, NULL))) goto exit; *p++ = G_DIR_SEPARATOR; *p = '\0'; q = g_stpcpy (output, path); *q++ = G_DIR_SEPARATOR; q = g_stpcpy (q, "output"); *q++ = G_DIR_SEPARATOR; *q = '\0'; while ((dent = g_dir_read_name (dir))) { if (!g_str_has_suffix (dent, ".mbox")) continue; strcpy (p, dent); strcpy (q, dent); tmp = NULL; parser = NULL; istream = NULL; ostream = NULL; mstream = NULL; pstream = NULL; testsuite_check ("%s", dent); try { if (!(istream = g_mime_stream_fs_open (input, O_RDONLY, 0, NULL))) { throw (exception_new ("could not open `%s': %s", input, g_strerror (errno))); } if (!(ostream = g_mime_stream_fs_open (output, O_RDONLY, 0, NULL))) { throw (exception_new ("could not open `%s': %s", output, g_strerror (errno))); } #ifdef ENABLE_MBOX_MATCH tmp = g_strdup_printf ("./tmp/%s", dent); if ((fd = open (tmp, O_CREAT | O_RDWR | O_TRUNC, 0644)) == -1) { throw (exception_new ("could not open `%s': %s", tmp, g_strerror (errno))); } mstream = g_mime_stream_fs_new (fd); #endif parser = g_mime_parser_new_with_stream (istream); g_mime_parser_set_persist_stream (parser, TRUE); g_mime_parser_set_format (parser, GMIME_FORMAT_MBOX); if (!g_mime_parser_get_persist_stream (parser)) throw (exception_new ("persist stream check failed")); if (g_mime_parser_get_format (parser) != GMIME_FORMAT_MBOX) throw (exception_new ("format check failed")); if (strstr (dent, "content-length") != NULL) { g_mime_parser_set_respect_content_length (parser, TRUE); if (!g_mime_parser_get_respect_content_length (parser)) throw (exception_new ("respect content-length check failed")); } else { g_mime_parser_set_respect_content_length (parser, FALSE); if (g_mime_parser_get_respect_content_length (parser)) throw (exception_new ("respect content-length check failed")); } g_mime_parser_set_header_regex (parser, "^X-Evolution", xevcb, NULL); pstream = g_mime_stream_mem_new (); test_parser (parser, mstream, pstream); #ifdef ENABLE_MBOX_MATCH g_mime_stream_flush (mstream); g_mime_stream_reset (istream); g_mime_stream_reset (mstream); if (!streams_match (istream, mstream)) throw (exception_new ("mboxes do not match for `%s'", dent)); #endif g_mime_stream_reset (ostream); g_mime_stream_reset (pstream); if (!streams_match (ostream, pstream)) throw (exception_new ("summaries do not match for `%s'", dent)); testsuite_check_passed (); #ifdef ENABLE_MBOX_MATCH unlink (tmp); #endif } catch (ex) { if (parser != NULL) testsuite_check_failed ("%s: %s", dent, ex->message); else testsuite_check_warn ("%s: %s", dent, ex->message); } finally; if (mstream != NULL) g_object_unref (mstream); if (pstream != NULL) g_object_unref (pstream); if (istream != NULL) g_object_unref (istream); if (ostream != NULL) g_object_unref (ostream); if (parser != NULL) g_object_unref (parser); g_free (tmp); } g_dir_close (dir); } else if (S_ISREG (st.st_mode)) { /* manually run test on a single file */ if (!(istream = g_mime_stream_fs_open (path, O_RDONLY, 0, NULL))) goto exit; parser = g_mime_parser_new_with_stream (istream); g_mime_parser_set_format (parser, GMIME_FORMAT_MBOX); #ifdef ENABLE_MBOX_MATCH tmp = g_strdup ("./tmp/mbox-test.XXXXXX"); if ((fd = g_mkstemp (tmp)) == -1) { g_object_unref (istream); g_object_unref (parser); g_free (tmp); goto exit; } mstream = g_mime_stream_fs_new (fd); #else mstream = NULL; #endif ostream = g_mime_stream_file_new (stdout); g_mime_stream_file_set_owner ((GMimeStreamFile *) ostream, FALSE); testsuite_check ("user-input mbox: `%s'", path); try { test_parser (parser, mstream, ostream); #ifdef ENABLE_MBOX_MATCH g_mime_stream_reset (istream); g_mime_stream_reset (mstream); if (!streams_match (istream, mstream)) throw (exception_new ("`%s' does not match `%s'", tmp, path)); unlink (tmp); #endif testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("user-input mbox `%s': %s", path, ex->message); } finally; g_object_unref (istream); g_object_unref (ostream); g_object_unref (parser); #ifdef ENABLE_MBOX_MATCH g_object_unref (mstream); g_free (tmp); #endif } else { goto exit; } exit: #ifdef ENABLE_MBOX_MATCH //if ((dir = g_dir_open ("./tmp", 0, NULL))) { // p = g_stpcpy (input, "./tmp"); // *p++ = G_DIR_SEPARATOR; // // while ((dent = g_dir_read_name (dir))) { // strcpy (p, dent); // unlink (input); // } // // g_dir_close (dir); //} //rmdir ("./tmp"); #endif testsuite_end (); g_mime_shutdown (); return testsuite_exit (); }
int main (int argc, char **argv) { const char *datadir = "data/cat"; struct _StreamPart *list, *tail, *n; gboolean failed = FALSE; gint64 wholelen, left; GMimeStream *whole; guint32 part = 0; gint64 start = 0; char *filename; struct stat st; gint64 len; int fd, i; srand (time (NULL)); g_mime_init (0); testsuite_init (argc, argv); for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { datadir = argv[i]; break; } } if (i < argc) { if (stat (datadir, &st) == -1) { if (errno == ENOENT) { g_mkdir_with_parents (datadir, 0755); if (stat (datadir, &st) == -1) return EXIT_FAILURE; } else return EXIT_FAILURE; } if (S_ISREG (st.st_mode)) { /* test a particular input file */ if ((fd = open (argv[i], O_RDONLY, 0)) == -1) return EXIT_FAILURE; filename = g_strdup (argv[i]); whole = g_mime_stream_fs_new (fd); } else if (S_ISDIR (st.st_mode)) { /* use path as test suite data dir */ whole = random_whole_stream (argv[i], &filename); } else { return EXIT_FAILURE; } } else { whole = random_whole_stream (datadir, &filename); } if ((wholelen = g_mime_stream_length (whole)) == -1) { fprintf (stderr, "Error: length of test stream unknown\n"); g_object_unref (whole); return EXIT_FAILURE; } else if (wholelen == 64) { fprintf (stderr, "Error: length of test stream is unsuitable for testing\n"); g_object_unref (whole); return EXIT_FAILURE; } list = NULL; tail = (struct _StreamPart *) &list; left = wholelen; while (left > 0) { len = 1 + (gint64) (left * (rand () / (RAND_MAX + 1.0))); n = g_new (struct _StreamPart, 1); sprintf (n->filename, "%s.%u", filename, part++); n->pstart = (gint64) 0; /* FIXME: we could make this a random offset */ n->pend = n->pstart + len; n->wend = start + len; n->wstart = start; tail->next = n; tail = n; start += len; left -= len; } tail->next = NULL; testsuite_start ("GMimeStreamCat"); for (i = 0; i < G_N_ELEMENTS (checks) && !failed; i++) { testsuite_check (checks[i].what); try { checks[i].check (whole, list, checks[i].bounded); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", checks[i].what, ex->message); failed = TRUE; } finally; } testsuite_end (); while (list != NULL) { n = list->next; if (!failed) unlink (list->filename); g_free (list); list = n; } g_object_unref (whole); if (!failed) unlink (filename); g_free (filename); g_mime_shutdown (); return testsuite_exit (); }
static void test_address_sync (void) { const char *raw_value, *value; InternetAddress *addr, *ia; InternetAddressList *list; GMimeHeaderList *headers; GMimeMessage *message; GMimeObject *object; GMimeHeader *header; message = g_mime_message_new (TRUE); list = g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_TO); object = (GMimeObject *) message; headers = object->headers; testsuite_check ("address header synchronization"); try { /* first, check that the To recipients are empty */ if (list == NULL || internet_address_list_length (list) != 0) throw (exception_new ("unexpected initial internet address list")); /* now check that the initial header value is null */ if ((value = g_mime_object_get_header (object, "To")) != NULL) throw (exception_new ("unexpected initial value")); header = g_mime_header_list_get_header (headers, "To"); if ((raw_value = g_mime_header_get_raw_value (header)) != NULL) throw (exception_new ("unexpected initial raw_value")); /* now try adding an address */ addr = internet_address_mailbox_new ("Tester", "*****@*****.**"); internet_address_list_add (list, addr); if (!(value = g_mime_object_get_header (object, "To"))) throw (exception_new ("address list header unexpectedly null after adding recipient")); if (strcmp ("Tester <*****@*****.**>", value) != 0) throw (exception_new ("unexpected address list header after adding recipient")); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after adding recipient")); if (strcmp (" Tester <*****@*****.**>\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after adding recipient: %s", raw_value)); /* now let's try changing the address name to make sure signals properly chain up */ internet_address_set_name (addr, "Eva Lucy-Ann Tester"); if (!(value = g_mime_object_get_header (object, "To"))) throw (exception_new ("address list header unexpectedly null after changing name")); if (strcmp ("Eva Lucy-Ann Tester <*****@*****.**>", value) != 0) throw (exception_new ("unexpected address list header after changing name: %s", value)); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after changing name")); if (strcmp (" Eva Lucy-Ann Tester <*****@*****.**>\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after changing name")); /* now let's try changing the address mailbox... */ internet_address_mailbox_set_addr ((InternetAddressMailbox *) addr, "*****@*****.**"); if (!(value = g_mime_object_get_header (object, "To"))) throw (exception_new ("address list header unexpectedly null after changing mailbox")); if (strcmp ("Eva Lucy-Ann Tester <*****@*****.**>", value) != 0) throw (exception_new ("unexpected address list header after changing mailbox")); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after changing mailbox")); if (strcmp (" Eva Lucy-Ann Tester <*****@*****.**>\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after changing mailbox")); /* now let's try inserting a group address */ g_object_unref (addr); addr = internet_address_group_new ("Group"); internet_address_list_insert (list, 0, addr); if (!(value = g_mime_object_get_header (object, "To"))) throw (exception_new ("address list header unexpectedly null after inserting group")); if (strcmp ("Group: ;, Eva Lucy-Ann Tester <*****@*****.**>", value) != 0) throw (exception_new ("unexpected address list header after inserting group")); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after inserting group")); if (strcmp (" Group: ;, Eva Lucy-Ann Tester <*****@*****.**>\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after inserting group")); /* now let's try removing the original recipient */ internet_address_list_remove_at (list, 1); if (!(value = g_mime_object_get_header (object, "To"))) throw (exception_new ("address list header unexpectedly null after removing recipient")); if (strcmp ("Group: ;", value) != 0) throw (exception_new ("unexpected address list header after removing recipient")); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after removing recipient")); if (strcmp (" Group: ;\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after removing recipient")); /* now let's try adding an address to the group... */ ia = internet_address_mailbox_new ("Tester", "*****@*****.**"); internet_address_list_add (((InternetAddressGroup *) addr)->members, ia); if (!(value = g_mime_object_get_header (object, "To"))) throw (exception_new ("address list header unexpectedly null after adding addr to group")); if (strcmp ("Group: Tester <*****@*****.**>;", value) != 0) throw (exception_new ("unexpected address list header after adding addr to group")); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after adding addr to group")); if (strcmp (" Group: Tester <*****@*****.**>;\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after adding addr to group")); /* let's try this in reverse... set the header value and make sure InternetAddressList gets updated */ g_mime_object_set_header (object, "To", "[email protected] (=?iso-8859-1?q?Fran=E7ois?= Pons)", NULL); if (internet_address_list_length (list) != 1) throw (exception_new ("unexpected number of addresses in addrlist after setting header value")); ia = internet_address_list_get_address (list, 0); value = internet_address_get_name (ia); if (strcmp ("Fran\xc3\xa7ois Pons", value) != 0) throw (exception_new ("unexpected name after setting header value")); value = internet_address_mailbox_get_addr ((InternetAddressMailbox *) ia); if (strcmp ("*****@*****.**", value) != 0) throw (exception_new ("unexpected addr after setting header value")); header = g_mime_header_list_get_header (headers, "To"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("raw_value is null after setting header value")); if (strcmp (" =?iso-8859-1?q?Fran=E7ois?= Pons <*****@*****.**>\n", raw_value) != 0) throw (exception_new ("unexpected raw_value after setting header value: %s", raw_value)); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("address header not synchronized: %s", ex->message); } finally; g_object_unref (message); }
static void test_disposition_sync (void) { GMimeContentDisposition *disposition; const char *raw_value, *value; GMimeHeaderList *headers; GMimeParamList *params; GMimeObject *object; GMimeHeader *header; GMimePart *part; object = (GMimeObject *) (part = g_mime_part_new ()); headers = g_mime_object_get_header_list (object); testsuite_check ("content-disposition synchronization"); try { g_mime_object_set_disposition (object, "attachment"); /* first, check that the current Content-Disposition header * value is "application/octet-stream" as expected */ if (!(value = g_mime_object_get_header (object, "Content-Disposition"))) throw (exception_new ("initial content-disposition header was unexpectedly null")); if (strcmp ("attachment", value) != 0) throw (exception_new ("initial content-disposition header had unexpected value: %s", value)); header = g_mime_header_list_get_header (headers, "Content-Disposition"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("initial content-disposition raw_value was unexpectedly null")); if (strcmp (" attachment\n", raw_value) != 0) throw (exception_new ("initial content-disposition raw_value had unexpected value: %s", raw_value)); /* now change the content-disposition's disposition */ disposition = g_mime_object_get_content_disposition (object); g_mime_content_disposition_set_disposition (disposition, "inline"); if (!(value = g_mime_object_get_header (object, "Content-Disposition"))) throw (exception_new ("content-disposition header was unexpectedly null after changing type")); if (strcmp ("inline", value) != 0) throw (exception_new ("content-disposition header had unexpected value after changing type")); header = g_mime_header_list_get_header (headers, "Content-Disposition"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-disposition raw_value was unexpectedly null after changing type")); if (strcmp (" inline\n", raw_value) != 0) throw (exception_new ("content-disposition raw_value had unexpected value after changing type: %s", raw_value)); /* now change the content-disposition's parameters by setting a param */ g_mime_content_disposition_set_parameter (disposition, "filename", "hello.txt"); if (!(value = g_mime_object_get_header (object, "Content-Disposition"))) throw (exception_new ("content-disposition header was unexpectedly null after setting a param")); if (strcmp ("inline; filename=hello.txt", value) != 0) throw (exception_new ("content-disposition header had unexpected value after setting a param")); header = g_mime_header_list_get_header (headers, "Content-Disposition"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-disposition raw_value was unexpectedly null after setting a param")); if (strcmp (" inline; filename=hello.txt\n", raw_value) != 0) throw (exception_new ("content-disposition raw_value had unexpected value after setting a param: %s", raw_value)); /* now change the content-disposition's parameters by clearing the params */ params = g_mime_content_disposition_get_parameters (disposition); g_mime_param_list_clear (params); if (!(value = g_mime_object_get_header (object, "Content-Disposition"))) throw (exception_new ("content-disposition header was unexpectedly null after clearing params")); if (strcmp ("inline", value) != 0) throw (exception_new ("content-disposition header had unexpected value after clearing params")); header = g_mime_header_list_get_header (headers, "Content-Disposition"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-disposition raw_value was unexpectedly null after clearing params")); if (strcmp (" inline\n", raw_value) != 0) throw (exception_new ("content-disposition raw_value had unexpected value after clearing params: %s", raw_value)); /* let's try this in reverse... set the header value and make sure GMimeContentDisposition gets updated */ header = g_mime_header_list_get_header_at (headers, 1); g_mime_header_set_value (header, NULL, "attachment; filename=xyz", NULL); disposition = g_mime_object_get_content_disposition (object); if (!g_mime_content_disposition_is_attachment (disposition)) throw (exception_new ("GMimeContentDisposition object was not updated")); header = g_mime_header_list_get_header (headers, "Content-Disposition"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-disposition raw_value was unexpectedly null after setting value")); if (strcmp (" attachment; filename=xyz\n", raw_value) != 0) throw (exception_new ("content-disposition raw_value had unexpected value after setting value: %s", raw_value)); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("content-disposition header not synchronized: %s", ex->message); } finally; g_object_unref (part); }
static void test_content_type_sync (void) { const char *raw_value, *value; GMimeHeaderList *headers; GMimeContentType *type; GMimeParamList *params; GMimeObject *object; GMimeHeader *header; GMimePart *part; object = (GMimeObject *) (part = g_mime_part_new ()); headers = g_mime_object_get_header_list (object); testsuite_check ("content-type synchronization"); try { /* first, check that the current Content-Type header * value is "application/octet-stream" as expected */ if (!(value = g_mime_object_get_header (object, "Content-Type"))) throw (exception_new ("initial content-type header was unexpectedly null")); if (strcmp ("application/octet-stream", value) != 0) throw (exception_new ("initial content-type header had unexpected value: %s", value)); /* now change the content-type's media type... */ type = g_mime_object_get_content_type (object); g_mime_content_type_set_media_type (type, "text"); if (!(value = g_mime_object_get_header (object, "Content-Type"))) throw (exception_new ("content-type header was unexpectedly null after changing type")); if (strcmp ("text/octet-stream", value) != 0) throw (exception_new ("content-type header had unexpected value after changing type")); header = g_mime_header_list_get_header (headers, "Content-Type"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-type raw_value was unexpectedly null after changing type")); if (strcmp (" text/octet-stream\n", raw_value) != 0) throw (exception_new ("content-type raw_value had unexpected value after changing type")); /* now change the content-type's media subtype... */ g_mime_content_type_set_media_subtype (type, "plain"); if (!(value = g_mime_object_get_header (object, "Content-Type"))) throw (exception_new ("content-type header was unexpectedly null after changing subtype")); if (strcmp ("text/plain", value) != 0) throw (exception_new ("content-type header had unexpected value after changing subtype")); header = g_mime_header_list_get_header (headers, "Content-Type"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-type raw_value was unexpectedly null after changing subtype")); if (strcmp (" text/plain\n", raw_value) != 0) throw (exception_new ("content-type raw_value had unexpected value after changing subtype")); /* now change the content-type's parameters by setting a param */ g_mime_content_type_set_parameter (type, "format", "flowed"); if (!(value = g_mime_object_get_header (object, "Content-Type"))) throw (exception_new ("content-type header was unexpectedly null after setting a param")); if (strcmp ("text/plain; format=flowed", value) != 0) throw (exception_new ("content-type header had unexpected value after setting a param")); header = g_mime_header_list_get_header (headers, "Content-Type"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-type raw_value was unexpectedly null after setting a param")); if (strcmp (" text/plain; format=flowed\n", raw_value) != 0) throw (exception_new ("content-type raw_value had unexpected value after setting a param")); /* now change the content-type's parameters by clearing the params */ params = g_mime_content_type_get_parameters (type); g_mime_param_list_clear (params); if (!(value = g_mime_object_get_header (object, "Content-Type"))) throw (exception_new ("content-type header was unexpectedly null after clearing params")); if (strcmp ("text/plain", value) != 0) throw (exception_new ("content-type header had unexpected value after clearing params")); header = g_mime_header_list_get_header (headers, "Content-Type"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-type raw_value was unexpectedly null after clearing params")); if (strcmp (" text/plain\n", raw_value) != 0) throw (exception_new ("content-type raw_value had unexpected value after clearing params")); /* let's try this in reverse... set the header value and make sure GMimeContentType gets updated */ header = g_mime_header_list_get_header_at (headers, 0); g_mime_header_set_value (header, NULL, "text/html; charset=utf-8", NULL); type = g_mime_object_get_content_type (object); if (!g_mime_content_type_is_type (type, "text", "html")) throw (exception_new ("GMimeContentType object was not updated")); header = g_mime_header_list_get_header (headers, "Content-Type"); if (!(raw_value = g_mime_header_get_raw_value (header))) throw (exception_new ("content-type raw_value was unexpectedly null after setting value")); if (strcmp (" text/html; charset=utf-8\n", raw_value) != 0) throw (exception_new ("content-type raw_value had unexpected value after setting value")); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("content-type header not synchronized: %s", ex->message); } finally; g_object_unref (part); }
int main (int argc, char **argv) { #ifdef ENABLE_CRYPTO const char *datadir = "data/pgp"; GMimeStream *istream, *ostream; GMimeFilterOpenPGP *filter; GMimeCryptoContext *ctx; const char *what; char *gpg, *key; struct stat st; int i; g_mime_init (); testsuite_init (argc, argv); if (!(gpg = g_find_program_in_path ("gpg2"))) if (!(gpg = g_find_program_in_path ("gpg"))) return EXIT_FAILURE; if (testsuite_setup_gpghome (gpg) != 0) return EXIT_FAILURE; g_free (gpg); for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { datadir = argv[i]; break; } } if (i < argc && (stat (datadir, &st) == -1 || !S_ISDIR (st.st_mode))) return 0; testsuite_start ("GnuPG crypto context"); ctx = g_mime_gpg_context_new (); g_mime_crypto_context_set_request_password (ctx, request_passwd); testsuite_check ("GMimeGpgContext::import"); try { key = g_build_filename (datadir, "gmime.gpg.pub", NULL); import_key (ctx, key); g_free (key); key = g_build_filename (datadir, "gmime.gpg.sec", NULL); import_key (ctx, key); g_free (key); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("GMimeGpgContext::import failed: %s", ex->message); return EXIT_FAILURE; } finally; key = g_build_filename (datadir, "gmime.gpg.pub", NULL); testsuite_check ("GMimeGpgContext::export"); try { test_export (ctx, key); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("GMimeGpgContext::export failed: %s", ex->message); } finally; g_free (key); istream = g_mime_stream_mem_new (); ostream = g_mime_stream_mem_new (); g_mime_stream_write_string (istream, "this is some cleartext\r\n"); g_mime_stream_reset (istream); what = "GMimeGpgContext::sign"; testsuite_check ("%s", what); try { test_sign (ctx, FALSE, istream, ostream); testsuite_check_passed (); what = "GMimeGpgContext::verify"; testsuite_check ("%s", what); g_mime_stream_reset (istream); g_mime_stream_reset (ostream); test_verify (ctx, istream, ostream); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_object_unref (ostream); g_mime_stream_reset (istream); ostream = g_mime_stream_mem_new (); what = "GMimeGpgContext::sign (detached)"; testsuite_check ("%s", what); try { test_sign (ctx, TRUE, istream, ostream); testsuite_check_passed (); what = "GMimeGpgContext::verify (detached)"; testsuite_check ("%s", what); g_mime_stream_reset (istream); g_mime_stream_reset (ostream); test_verify_detached (ctx, istream, ostream); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_object_unref (ostream); g_mime_stream_reset (istream); ostream = g_mime_stream_mem_new (); what = "GMimeGpgContext::encrypt"; testsuite_check ("%s", what); try { test_encrypt (ctx, FALSE, istream, ostream); testsuite_check_passed (); what = "GMimeGpgContext::decrypt"; testsuite_check ("%s", what); g_mime_stream_reset (istream); g_mime_stream_reset (ostream); test_decrypt (ctx, FALSE, istream, ostream); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_object_unref (ostream); g_mime_stream_reset (istream); ostream = g_mime_stream_mem_new (); what = "GMimeGpgContext::encrypt+sign"; testsuite_check ("%s", what); try { test_encrypt (ctx, TRUE, istream, ostream); testsuite_check_passed (); what = "GMimeGpgContext::decrypt+verify"; testsuite_check ("%s", what); g_mime_stream_reset (istream); g_mime_stream_reset (ostream); test_decrypt (ctx, TRUE, istream, ostream); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_object_unref (istream); g_object_unref (ostream); g_object_unref (ctx); filter = (GMimeFilterOpenPGP *) g_mime_filter_openpgp_new (); what = "GMimeFilterOpenPGP::public key block"; testsuite_check ("%s", what); try { key = g_build_filename (datadir, "gmime.gpg.pub", NULL); test_openpgp_filter (filter, key, GMIME_OPENPGP_DATA_PUBLIC_KEY, 0, 1720); g_free (key); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_mime_filter_reset ((GMimeFilter *) filter); what = "GMimeFilterOpenPGP::private key block"; testsuite_check ("%s", what); try { key = g_build_filename (datadir, "gmime.gpg.sec", NULL); test_openpgp_filter (filter, key, GMIME_OPENPGP_DATA_PRIVATE_KEY, 0, 1928); g_free (key); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_mime_filter_reset ((GMimeFilter *) filter); what = "GMimeFilterOpenPGP::signed message block"; testsuite_check ("%s", what); try { key = g_build_filename (datadir, "signed-message.txt", NULL); test_openpgp_filter (filter, key, GMIME_OPENPGP_DATA_SIGNED, 162, 440); g_free (key); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_mime_filter_reset ((GMimeFilter *) filter); what = "GMimeFilterOpenPGP::encrypted message block"; testsuite_check ("%s", what); try { key = g_build_filename (datadir, "encrypted-message.txt", NULL); test_openpgp_filter (filter, key, GMIME_OPENPGP_DATA_ENCRYPTED, 165, 1084); g_free (key); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("%s failed: %s", what, ex->message); } finally; g_object_unref (filter); testsuite_end (); g_mime_shutdown (); if (testsuite_destroy_gpghome () != 0) return EXIT_FAILURE; return testsuite_exit (); #else fprintf (stderr, "PGP support not enabled in this build.\n"); return EXIT_SUCCESS; #endif }
static void test_gunzip (const char *datadir, const char *filename) { char *name = g_strdup_printf ("%s.gz", filename); char *path = g_build_filename (datadir, name, NULL); const char *what = "GMimeFilterGzip::unzip"; GByteArray *actual, *expected; GMimeStream *stream; GMimeFilter *filter; const char *value; testsuite_check ("%s", what); actual = g_byte_array_new (); stream = g_mime_stream_mem_new_with_byte_array (actual); g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE); filter = g_mime_filter_gzip_new (GMIME_FILTER_GZIP_MODE_UNZIP, 9); pump_data_through_filter (filter, path, stream, FALSE, TRUE); g_object_unref (stream); g_free (path); g_free (name); path = g_build_filename (datadir, filename, NULL); expected = read_all_bytes (path, TRUE); g_free (path); if (actual->len != expected->len) { testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u", what, expected->len, actual->len); goto error; } if (memcmp (actual->data, expected->data, actual->len) != 0) { testsuite_check_failed ("%s failed: stream contents do not match", what); goto error; } value = g_mime_filter_gzip_get_filename ((GMimeFilterGZip *) filter); if (!value || strcmp (value, filename) != 0) { testsuite_check_failed ("%s failed: filename does not match: %s", what, value); goto error; } value = g_mime_filter_gzip_get_comment ((GMimeFilterGZip *) filter); if (!value || strcmp (value, "This is a comment.") != 0) { testsuite_check_failed ("%s failed: comment does not match: %s", what, value); goto error; } testsuite_check_passed (); error: g_byte_array_free (expected, TRUE); g_byte_array_free (actual, TRUE); g_mime_filter_reset (filter); g_object_unref (filter); }