int main (int argc, char **argv)
{
g_mime_init ();
testsuite_init (argc, argv);
testsuite_start ("indexing");
test_indexing ();
testsuite_end ();
testsuite_start ("removing");
test_remove ();
testsuite_end ();
testsuite_start ("removing at an index");
test_remove_at ();
testsuite_end ();
testsuite_start ("header synchronization");
test_content_type_sync ();
test_disposition_sync ();
test_address_sync ();
testsuite_end ();
testsuite_start ("header formatting");
test_header_formatting ();
testsuite_end ();
g_mime_shutdown ();
return testsuite_exit ();
}
int main (int argc, char **argv)
{
const char *datadir = "data/filters";
struct stat st;
int i;
g_mime_init ();
testsuite_init (argc, argv);
//verbose = 4;
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 ("GMimeFilter");
//test_charset_conversion (datadir, "chinese", "utf-8", "big5"); // Note: utf-8 -> big5 drops characters
test_charset_conversion (datadir, "cyrillic", "utf-8", "cp1251");
test_charset_conversion (datadir, "cyrillic", "cp1251", "utf-8");
test_charset_conversion (datadir, "cyrillic", "utf-8", "iso-8859-5");
test_charset_conversion (datadir, "cyrillic", "iso-8859-5", "utf-8");
test_charset_conversion (datadir, "cyrillic", "utf-8", "koi8-r");
test_charset_conversion (datadir, "cyrillic", "koi8-r", "utf-8");
test_charset_conversion (datadir, "japanese", "utf-8", "iso-2022-jp");
test_charset_conversion (datadir, "japanese", "iso-2022-jp", "utf-8");
test_charset_conversion (datadir, "japanese", "utf-8", "shift-jis");
test_charset_conversion (datadir, "japanese", "shift-jis", "utf-8");
test_enriched (datadir, "enriched.txt", "enriched.html");
test_gzip (datadir, "lorem-ipsum.txt");
test_gunzip (datadir, "lorem-ipsum.txt");
test_html (datadir, "html-input.txt", "html-output.blockquote.html", GMIME_FILTER_HTML_BLOCKQUOTE_CITATION);
test_html (datadir, "html-input.txt", "html-output.mark.html", GMIME_FILTER_HTML_MARK_CITATION);
test_html (datadir, "html-input.txt", "html-output.cite.html", GMIME_FILTER_HTML_CITE);
test_smtp_data (datadir, "smtp-input.txt", "smtp-output.txt");
test_windows (datadir, "french-fable.cp1252.txt", "iso-8859-1", "windows-cp1252");
testsuite_end ();
g_mime_shutdown ();
return testsuite_exit ();
}
int main (int argc, char **argv)
{
const char *datadir = "data/streams";
gboolean gen_data = TRUE;
char *stream_name = NULL;
char path[256], *p;
GDir *dir, *outdir;
const char *dent;
int i;
g_mime_init (0);
testsuite_init (argc, argv);
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
datadir = argv[i];
break;
}
}
testsuite_start ("Stream tests");
p = g_stpcpy (path, datadir);
*p++ = G_DIR_SEPARATOR;
strcpy (p, "output");
if (!(outdir = g_dir_open (path, 0, NULL))) {
if (gen_test_data (datadir, &stream_name) == -1 ||
!(outdir = g_dir_open (path, 0, NULL)))
goto exit;
gen_data = FALSE;
}
p = g_stpcpy (p, "input");
if (!(dir = g_dir_open (path, 0, NULL))) {
if (!gen_data || gen_test_data (datadir, &stream_name) == -1 ||
!(dir = g_dir_open (path, 0, NULL))) {
g_dir_close (outdir);
goto exit;
}
gen_data = FALSE;
}
if (gen_data) {
while ((dent = g_dir_read_name (dir))) {
if (dent[0] == '.' || !strcmp (dent, "README"))
continue;
gen_data = FALSE;
break;
}
g_dir_rewind (dir);
if (gen_data && gen_test_data (datadir, &stream_name) == -1)
goto exit;
}
*p++ = G_DIR_SEPARATOR;
*p = '\0';
while ((dent = g_dir_read_name (dir))) {
if (dent[0] == '.' || !strcmp (dent, "README"))
continue;
test_streams (outdir, datadir, dent);
strcpy (p, dent);
test_stream_buffer_gets (path);
}
if (gen_data && stream_name && testsuite_total_errors () == 0) {
/* since all tests were successful, unlink the generated test data */
strcpy (p, stream_name);
unlink (path);
p = g_stpcpy (path, datadir);
*p++ = G_DIR_SEPARATOR;
p = g_stpcpy (p, "output");
*p++ = G_DIR_SEPARATOR;
g_dir_rewind (outdir);
while ((dent = g_dir_read_name (outdir))) {
if (!strncmp (dent, stream_name, strlen (stream_name))) {
strcpy (p, dent);
unlink (path);
}
}
g_free (stream_name);
}
g_dir_close (outdir);
g_dir_close (dir);
exit:
testsuite_end ();
g_mime_shutdown ();
return testsuite_exit ();
}
int main(int argc, char **argv)
{
struct sieve_instance *svinst;
const char *scriptfile, *dumpfile, *tracefile;
struct sieve_trace_config tr_config;
struct sieve_binary *sbin;
const char *sieve_dir;
bool log_stdout = FALSE;
int ret, c;
sieve_tool = sieve_tool_init
("testsuite", &argc, &argv, "d:t:T:EDP:", TRUE);
/* Parse arguments */
scriptfile = dumpfile = tracefile = NULL;
memset(&tr_config, 0, sizeof(tr_config));
tr_config.level = SIEVE_TRLVL_ACTIONS;
while ((c = sieve_tool_getopt(sieve_tool)) > 0) {
switch (c) {
case 'd':
/* destination address */
dumpfile = optarg;
break;
case 't':
/* trace file */
tracefile = optarg;
break;
case 'T':
sieve_tool_parse_trace_option(&tr_config, optarg);
break;
case 'E':
log_stdout = TRUE;
break;
default:
print_help();
i_fatal_status(EX_USAGE,
"Unknown argument: %c", c);
break;
}
}
if ( optind < argc ) {
scriptfile = t_strdup(argv[optind++]);
} else {
print_help();
i_fatal_status(EX_USAGE, "Missing <scriptfile> argument");
}
if (optind != argc) {
print_help();
i_fatal_status(EX_USAGE, "Unknown argument: %s", argv[optind]);
}
/* Initialize mail user */
sieve_tool_set_homedir(sieve_tool, t_abspath(""));
/* Initialize settings environment */
testsuite_settings_init();
/* Currently needed for include (FIXME) */
sieve_dir = strrchr(scriptfile, '/');
if ( sieve_dir == NULL )
sieve_dir= "./";
else {
sieve_dir = t_strdup_until(scriptfile, sieve_dir+1);
}
testsuite_setting_set
("sieve_dir", t_strconcat(sieve_dir, "included", NULL));
testsuite_setting_set
("sieve_global_dir", t_strconcat(sieve_dir, "included-global", NULL));
/* Finish testsuite initialization */
svinst = sieve_tool_init_finish(sieve_tool, FALSE);
testsuite_init(svinst, log_stdout);
printf("Test case: %s:\n\n", scriptfile);
/* Compile sieve script */
if ( (sbin = sieve_compile
(svinst, scriptfile, NULL, testsuite_log_main_ehandler, NULL)) != NULL ) {
struct ostream *tracestream = NULL;
struct sieve_script_env scriptenv;
/* Dump script */
sieve_tool_dump_binary_to(sbin, dumpfile, FALSE);
if ( tracefile != NULL )
tracestream = sieve_tool_open_output_stream(tracefile);
testsuite_mailstore_init();
testsuite_message_init();
memset(&scriptenv, 0, sizeof(scriptenv));
scriptenv.user = sieve_tool_get_mail_user(sieve_tool);
scriptenv.default_mailbox = "INBOX";
scriptenv.hostname = "testsuite.example.com";
scriptenv.postmaster_address = "*****@*****.**";
scriptenv.username = sieve_tool_get_username(sieve_tool);
scriptenv.smtp_open = testsuite_smtp_open;
scriptenv.smtp_close = testsuite_smtp_close;
scriptenv.trace_stream = tracestream;
scriptenv.trace_config = tr_config;
testsuite_scriptenv = &scriptenv;
testsuite_result_init();
/* Run the test */
ret = testsuite_run
(sbin, &testsuite_msgdata, &scriptenv, testsuite_log_main_ehandler);
switch ( ret ) {
case SIEVE_EXEC_OK:
break;
case SIEVE_EXEC_FAILURE:
case SIEVE_EXEC_KEEP_FAILED:
testsuite_testcase_fail("test script execution aborted due to error");
break;
case SIEVE_EXEC_BIN_CORRUPT:
testsuite_testcase_fail("compiled test script binary is corrupt");
break;
default:
testsuite_testcase_fail("unknown execution exit code");
}
sieve_close(&sbin);
/* De-initialize message environment */
testsuite_message_deinit();
testsuite_mailstore_deinit();
testsuite_result_deinit();
if ( tracestream != NULL )
o_stream_unref(&tracestream);
} else {
testsuite_testcase_fail("failed to compile testcase script");
}
/* De-initialize testsuite */
testsuite_deinit();
testsuite_settings_deinit();
sieve_tool_deinit(&sieve_tool);
if ( !testsuite_testcase_result() )
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
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 ();
}
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
}
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 ();
}
