gint main (gint argc, gchar **argv) { gint i, j; camel_test_init (argc, argv); camel_test_start ("references decoding"); for (i = 0; i < G_N_ELEMENTS (test1); i++) { GSList *list; camel_test_push ("references decoding[%d] '%s'", i, test1[i].header); list = camel_header_references_decode (test1[i].header); for (j = 0; test1[i].values[j]; j++) { check_msg (list != NULL, "didn't find all references"); check (strcmp (test1[i].values[j], list->data) == 0); list = g_slist_next (list); } check_msg (list == NULL, "found more references than should have"); g_slist_free_full (list, g_free); camel_test_pull (); } camel_test_end (); return 0; }
int main(int argc, char **argv) { CamelSession *session; CamelException *ex; int i; camel_test_init(argc, argv); camel_test_provider_init(1, local_drivers); /* clear out any camel-test data */ system("/bin/rm -rf /tmp/camel-test"); ex = camel_exception_new(); session = camel_test_session_new ("/tmp/camel-test"); /* we iterate over all stores we want to test, with indexing or indexing turned on or off */ for (i=0;i<ARRAY_LEN(stores);i++) { char *name = stores[i]; test_folder_message_ops(session, name, TRUE, "testbox"); } /* create a pseudo-spool file, and check that */ creat("/tmp/camel-test/testbox", 0600); test_folder_message_ops(session, "spool:///tmp/camel-test/testbox", TRUE, "INBOX"); check_unref(session, 1); camel_exception_free(ex); return 0; }
gint main (gint argc, gchar **argv) { CamelSession *session; gint i; gchar *path; camel_test_init (argc, argv); camel_test_provider_init (1, imap_drivers); /* clear out any camel-test data */ system("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); /* todo: cross-check everything with folder_info checks as well */ /* todo: subscriptions? */ for (i = 0; i < G_N_ELEMENTS (remote_providers); i++) { path = getenv (remote_providers[i]); if (path == NULL) { printf("Aborted (ignored).\n"); printf("Set '%s', to re-run test.\n", remote_providers[i]); /* tells make check to ignore us in the total count */ _exit (77); } /*camel_test_nonfatal("The IMAP code is just rooted");*/ test_folder_basic (session, path, FALSE, FALSE); /*camel_test_fatal();*/ } g_object_unref (session); return 0; }
gint main (gint argc, gchar **argv) { CamelSession *session; gint i; gchar *path; camel_test_init (argc, argv); camel_test_provider_init (1, nntp_drivers); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); for (i = 0; i < G_N_ELEMENTS (remote_providers); i++) { path = getenv (remote_providers[i]); if (path == NULL) { printf ("Aborted (ignored).\n"); printf ("Set '%s', to re-run test.\n", remote_providers[i]); /* tells make check to ignore us in the total count */ _exit (77); } camel_test_nonfatal ("Dont know how many tests apply to NNTP"); test_folder_message_ops (session, path, FALSE, "testbox"); camel_test_fatal (); } check_unref (session, 1); return 0; }
int main (int argc, char **argv) { int i; camel_test_init(argc, argv); camel_test_start("HTML Stream filtering"); for (i=0;i<100;i++) { char inname[32], outname[32]; CamelMimeFilter *f; struct stat st; sprintf(inname, "data/html.%d.in", i); sprintf(outname, "data/html.%d.out", i); if (stat(inname, &st) == -1) break; f = camel_mime_filter_tohtml_new(CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS, 0); test_filter(f, inname, outname); check_unref(f, 1); } camel_test_end(); return 0; }
int main (int argc, char **argv) { int i, j; camel_test_init(argc, argv); camel_test_start("references decoding"); for (i=0;i<sizeof(test1)/sizeof(test1[0]);i++) { struct _camel_header_references *head, *node; camel_test_push("references decoding[%d] '%s'", i, test1[i].header); head = camel_header_references_decode(test1[i].header); node = head; for (j=0;test1[i].values[j];j++) { check_msg(node != NULL, "didn't find all references"); check(strcmp(test1[i].values[j], node->id) == 0); node = node->next; } check_msg(node == NULL, "found more references than should have"); camel_header_references_list_clear(&head); camel_test_pull(); } camel_test_end(); return 0; }
gint main (gint argc, gchar **argv) { gint i, j; struct _camel_search_words *words, *tmp; camel_test_init (argc, argv); camel_test_start ("Search splitting"); for (i = 0; i < G_N_ELEMENTS (split_tests); i++) { camel_test_push ("split %d '%s'", i, split_tests[i].word); words = camel_search_words_split (split_tests[i].word); check (words != NULL); check_msg (words->len == split_tests[i].count, "words->len = %d, count = %d", words->len, split_tests[i].count); for (j = 0; j < words->len; j++) { check_msg ( strcmp (split_tests[i].splits[j].word, words->words[j]->word) == 0, "'%s' != '%s'", split_tests[i].splits[j].word, words->words[j]->word); check (split_tests[i].splits[j].type == words->words[j]->type); } camel_search_words_free (words); camel_test_pull (); } camel_test_end (); camel_test_start ("Search splitting - simple"); for (i = 0; i < G_N_ELEMENTS (simple_tests); i++) { camel_test_push ("simple split %d '%s'", i, simple_tests[i].word); tmp = camel_search_words_split (simple_tests[i].word); check (tmp != NULL); words = camel_search_words_simple (tmp); check (words != NULL); check_msg (words->len == simple_tests[i].count, "words->len = %d, count = %d", words->len, simple_tests[i].count); for (j = 0; j < words->len; j++) { check_msg ( strcmp (simple_tests[i].splits[j].word, words->words[j]->word) == 0, "'%s' != '%s'", simple_tests[i].splits[j].word, words->words[j]->word); check (simple_tests[i].splits[j].type == words->words[j]->type); } camel_search_words_free (words); camel_search_words_free (tmp); camel_test_pull (); } camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { struct dirent *dent; DIR *dir; gint fd; camel_test_init (argc, argv); camel_test_start ("Message Test Suite"); if (!(dir = opendir ("../data/messages"))) return 77; while ((dent = readdir (dir)) != NULL) { CamelMimeMessage *message; CamelStream *stream; gchar *filename; struct stat st; if (dent->d_name[0] == '.') continue; filename = g_strdup_printf ("../data/messages/%s", dent->d_name); if (g_stat (filename, &st) == -1 || !S_ISREG (st.st_mode)) { g_free (filename); continue; } if ((fd = open (filename, O_RDONLY)) == -1) { g_free (filename); continue; } push ("testing message '%s'", filename); g_free (filename); stream = camel_stream_fs_new_with_fd (fd); message = camel_mime_message_new (); camel_data_wrapper_construct_from_stream_sync ( CAMEL_DATA_WRAPPER (message), stream, NULL, NULL); g_seekable_seek ( G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, NULL); /*dump_mime_struct ((CamelMimePart *) message, 0);*/ test_message_compare (message); g_object_unref (message); g_object_unref (stream); pull (); } closedir (dir); camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { gint i, j; GThread *threads[MAX_THREADS]; camel_test_init (argc, argv); camel_test_provider_init (1, local_drivers); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); for (testid = 0; testid < 2; testid++) { if (testid == 0) camel_test_start ("store and folder bag torture test, stacked references"); else camel_test_start ("store and folder bag torture test, unstacked references"); for (j = 0; j < G_N_ELEMENTS (local_providers); j++) { camel_test_push ("provider %s", local_providers[j]); path = g_strdup_printf ("%s:///tmp/camel-test/%s", local_providers[j], local_providers[j]); for (i = 0; i < MAX_THREADS; i++) { GError *error = NULL; threads[i] = g_thread_create (worker, NULL, TRUE, &error); if (error) { fprintf (stderr, "%s: Failed to create a thread: %s\n", G_STRFUNC, error->message); g_error_free (error); } } for (i = 0; i < MAX_THREADS; i++) { if (threads[i]) g_thread_join (threads[i]); } test_free (path); camel_test_pull (); } camel_test_end (); } g_object_unref (session); return 0; }
gint main (gint argc, gchar **argv) { CamelURL *base_url, *url; gchar *url_string; gint i; GError *error = NULL; camel_test_init (argc, argv); camel_test_start ("URL parsing"); camel_test_push ("base URL parsing"); base_url = camel_url_new (base, &error); if (!base_url) { camel_test_fail ( "Could not parse %s: %s\n", base, error->message); } camel_test_pull (); camel_test_push ("base URL unparsing"); url_string = camel_url_to_string (base_url, 0); if (strcmp (url_string, base) != 0) { camel_test_fail ("URL <%s> unparses to <%s>\n", base, url_string); } camel_test_pull (); g_free (url_string); for (i = 0; i < G_N_ELEMENTS (tests); i++) { camel_test_push ("<%s> + <%s> = <%s>?", base, tests[i].url_string, tests[i].result); url = camel_url_new_with_base (base_url, tests[i].url_string); if (!url) { camel_test_fail ("could not parse"); camel_test_pull (); continue; } url_string = camel_url_to_string (url, 0); if (strcmp (url_string, tests[i].result) != 0) camel_test_fail ("got <%s>!", url_string); g_free (url_string); camel_test_pull (); } camel_test_end (); return 0; }
int main(int argc, char **argv) { CamelException *ex; int i, j; pthread_t threads[MAX_THREADS]; camel_test_init(argc, argv); camel_test_provider_init(1, local_drivers); ex = camel_exception_new(); /* clear out any camel-test data */ system("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); for (testid=0;testid<2;testid++) { if (testid == 0) camel_test_start("store and folder bag torture test, stacked references"); else camel_test_start("store and folder bag torture test, unstacked references"); for (j=0;j<ARRAY_LEN(local_providers);j++) { camel_test_push("provider %s", local_providers[j]); path = g_strdup_printf("%s:///tmp/camel-test/%s", local_providers[j], local_providers[j]); for (i=0;i<MAX_THREADS;i++) pthread_create(&threads[i], 0, worker, NULL); for (i=0;i<MAX_THREADS;i++) pthread_join(threads[i], NULL); test_free(path); camel_test_pull(); } camel_test_end(); } camel_object_unref((CamelObject *)session); camel_exception_free(ex); return 0; }
int main (int argc, char **argv) { char *html, *url, *p; int i, errors = 0; guint32 flags; camel_test_init (argc, argv); camel_test_start ("URL scanning"); flags = CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS | CAMEL_MIME_FILTER_TOHTML_CONVERT_ADDRESSES; for (i = 0; i < num_url_tests; i++) { camel_test_push ("'%s' => '%s'", url_tests[i].text, url_tests[i].url ? url_tests[i].url : "None"); html = camel_text_to_html (url_tests[i].text, flags, 0); url = strstr (html, "href=\""); if (url) { url += 6; p = strchr (url, '"'); if (p) *p = '\0'; while ((p = strstr (url, "&"))) memmove (p + 1, p + 5, strlen (p + 5) + 1); } if ((url && (!url_tests[i].url || strcmp (url, url_tests[i].url) != 0)) || (!url && url_tests[i].url)) { printf ("FAILED on \"%s\" -> %s\n (got %s)\n\n", url_tests[i].text, url_tests[i].url ? url_tests[i].url : "(nothing)", url ? url : "(nothing)"); errors++; } g_free (html); } printf ("\n%d errors\n", errors); camel_test_end (); return errors; }
void camel_test_start (const gchar *what) { struct _state *s; CAMEL_TEST_LOCK; s = current_state (); if (!setup) camel_test_init (0, 0); ok = 1; s->test = g_strdup (what); if (camel_test_verbose > 0) { printf("Test: %s ... ", what); fflush (stdout); } CAMEL_TEST_UNLOCK; }
gint main (gint argc, gchar **argv) { CamelService *service; CamelSession *session; CamelStore *store; CamelFolder *folder; CamelMimeMessage *msg; gint i, j; CamelStream *mbox; CamelFilterDriver *driver; GError *error = NULL; camel_test_init (argc, argv); camel_test_provider_init (1, local_drivers); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); camel_test_start ("Simple filtering of mbox"); session = camel_test_session_new ("/tmp/camel-test"); /* todo: cross-check everything with folder_info checks as well */ /* todo: work out how to do imap/pop/nntp tests */ push ("getting store"); service = camel_session_add_service ( session, "test-uid", "mbox:///tmp/camel-test/mbox", CAMEL_PROVIDER_STORE, &error); check_msg (error == NULL, "getting store: %s", error->message); check (CAMEL_IS_STORE (service)); store = CAMEL_STORE (service); g_clear_error (&error); pull (); push ("Creating output folders"); for (i = 0; i < G_N_ELEMENTS (mailboxes); i++) { push ("creating %s", mailboxes[i].name); mailboxes[i].folder = folder = camel_store_get_folder_sync ( store, mailboxes[i].name, CAMEL_STORE_FOLDER_CREATE, NULL, &error); check_msg (error == NULL, "%s", error->message); check (folder != NULL); /* we need an empty folder for this to work */ test_folder_counts (folder, 0, 0); g_clear_error (&error); pull (); } pull (); /* append a bunch of messages with specific content */ push ("creating 100 test message mbox"); mbox = camel_stream_fs_new_with_name ("/tmp/camel-test/inbox", O_WRONLY|O_CREAT|O_EXCL, 0600, NULL); for (j = 0; j < 100; j++) { gchar *content, *subject; push ("creating test message"); msg = test_message_create_simple (); content = g_strdup_printf ("data%d content\n", j); test_message_set_content_simple ((CamelMimePart *)msg, 0, "text/plain", content, strlen (content)); test_free (content); subject = g_strdup_printf ("Test%d message%d subject", j, 100-j); camel_mime_message_set_subject (msg, subject); camel_mime_message_set_date (msg, j * 60 * 24, 0); pull (); camel_stream_write_string (mbox, "From \n", NULL, NULL); check (camel_data_wrapper_write_to_stream_sync ( CAMEL_DATA_WRAPPER (msg), mbox, NULL, NULL) != -1); #if 0 push ("appending simple message %d", j); camel_folder_append_message (folder, msg, NULL, ex); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); pull (); #endif test_free (subject); check_unref (msg, 1); } check (camel_stream_close (mbox, NULL, NULL) != -1); check_unref (mbox, 1); pull (); push ("Building filters"); driver = camel_filter_driver_new (session); camel_filter_driver_set_folder_func (driver, get_folder, NULL); for (i = 0; i < G_N_ELEMENTS (rules); i++) { camel_filter_driver_add_rule (driver, rules[i].name, rules[i].match, rules[i].action); } pull (); push ("Executing filters"); camel_filter_driver_set_default_folder (driver, mailboxes[0].folder); #if 0 /* FIXME We no longer filter mbox files. */ camel_filter_driver_filter_mbox ( driver, "/tmp/camel-test/inbox", NULL, NULL, &error); #endif check_msg (error == NULL, "%s", error->message); /* now need to check the folder counts/etc */ check_unref (driver, 1); g_clear_error (&error); pull (); /* this tests that invalid rules are caught */ push ("Testing broken match rules"); for (i = 0; i < G_N_ELEMENTS (brokens); i++) { push ("rule %s", brokens[i].match); driver = camel_filter_driver_new (session); camel_filter_driver_set_folder_func (driver, get_folder, NULL); camel_filter_driver_add_rule (driver, brokens[i].name, brokens[i].match, brokens[i].action); #if 0 /* FIXME We no longer filter mbox files. */ camel_filter_driver_filter_mbox ( driver, "/tmp/camel-test/inbox", NULL, NULL, &error); #endif check (error != NULL); check_unref (driver, 1); g_clear_error (&error); pull (); } pull (); push ("Testing broken action rules"); for (i = 0; i < G_N_ELEMENTS (brokena); i++) { push ("rule %s", brokena[i].action); driver = camel_filter_driver_new (session); camel_filter_driver_set_folder_func (driver, get_folder, NULL); camel_filter_driver_add_rule (driver, brokena[i].name, brokena[i].match, brokena[i].action); #if 0 /* FIXME We no longer filter mbox files. */ camel_filter_driver_filter_mbox ( driver, "/tmp/camel-test/inbox", NULL, NULL, &error); #endif check (error != NULL); check_unref (driver, 1); g_clear_error (&error); pull (); } pull (); for (i = 0; i < G_N_ELEMENTS (mailboxes); i++) { check_unref (mailboxes[i].folder, 1); } check_unref (store, 1); check_unref (session, 1); camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { CamelService *service; CamelSession *session; CamelStore *store; CamelFolder *folder; CamelMimeMessage *msg; gint i, j; gint indexed; GPtrArray *uids; GError *error = NULL; camel_test_init (argc, argv); camel_test_provider_init (1, local_drivers); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); /* todo: cross-check everything with folder_info checks as well */ /* todo: work out how to do imap/pop/nntp tests */ /* we iterate over all stores we want to test, with indexing or indexing turned on or off */ for (i = 0; i < G_N_ELEMENTS (stores); i++) { const gchar *name = stores[i]; for (indexed = 0; indexed < 2; indexed++) { gchar *what = g_strdup_printf ("folder search: %s (%sindexed)", name, indexed?"":"non-"); gchar *uid; gint flags; camel_test_start (what); test_free (what); push ("getting store"); uid = g_strdup_printf ("test-uid-%d", i); service = camel_session_add_service ( session, uid, stores[i], CAMEL_PROVIDER_STORE, &error); g_free (uid); check_msg (error == NULL, "adding store: %s", error->message); check (CAMEL_IS_STORE (service)); store = CAMEL_STORE (service); g_clear_error (&error); pull (); push ("creating %sindexed folder", indexed?"":"non-"); if (indexed) flags = CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_FOLDER_BODY_INDEX; else flags = CAMEL_STORE_FOLDER_CREATE; folder = camel_store_get_folder_sync ( store, "testbox", flags, NULL, &error); check_msg (error == NULL, "%s", error->message); check (folder != NULL); /* we need an empty folder for this to work */ test_folder_counts (folder, 0, 0); g_clear_error (&error); pull (); /* append a bunch of messages with specific content */ push ("appending 100 test messages"); for (j = 0; j < 100; j++) { gchar *content, *subject; push ("creating test message"); msg = test_message_create_simple (); content = g_strdup_printf ("data%d content\n", j); test_message_set_content_simple ( (CamelMimePart *) msg, 0, "text/plain", content, strlen (content)); test_free (content); subject = g_strdup_printf ("Test%d message%d subject", j, 100 - j); camel_mime_message_set_subject (msg, subject); camel_mime_message_set_date (msg, j * 60 * 24, 0); pull (); push ("appending simple message %d", j); camel_folder_append_message_sync ( folder, msg, NULL, NULL, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); pull (); test_free (subject); check_unref (msg, 1); } pull (); push ("Setting up some flags &c"); uids = camel_folder_get_uids (folder); check (uids->len == 100); for (j = 0; j < 100; j++) { gchar *uid = uids->pdata[j]; if ((j / 13) * 13 == j) { camel_folder_set_message_user_flag (folder, uid, "every13", TRUE); } if ((j / 17) * 17 == j) { camel_folder_set_message_user_flag (folder, uid, "every17", TRUE); } if ((j / 7) * 7 == j) { gchar *tag = g_strdup_printf ("7tag%d", j / 7); camel_folder_set_message_user_tag (folder, uid, "every7", tag); test_free (tag); } if ((j / 11) * 11 == j) { camel_folder_set_message_user_tag (folder, uid, "every11", "11tag"); } } camel_folder_free_uids (folder, uids); pull (); camel_test_nonfatal ("Index not guaranteed to be accurate before sync: should be fixed eventually"); push ("Search before sync"); run_search (folder, 100); pull (); camel_test_fatal (); push ("syncing folder, searching"); camel_folder_synchronize_sync ( folder, FALSE, NULL, NULL); run_search (folder, 100); pull (); push ("syncing wiht expunge, search"); camel_folder_synchronize_sync ( folder, TRUE, NULL, NULL); run_search (folder, 100); pull (); push ("deleting every 2nd message"); uids = camel_folder_get_uids (folder); check (uids->len == 100); for (j = 0; j < uids->len; j+=2) { camel_folder_delete_message (folder, uids->pdata[j]); } camel_folder_free_uids (folder, uids); run_search (folder, 100); push ("syncing"); camel_folder_synchronize_sync ( folder, FALSE, NULL, &error); check_msg (error == NULL, "%s", error->message); run_search (folder, 100); g_clear_error (&error); pull (); push ("expunging"); camel_folder_expunge_sync (folder, NULL, &error); check_msg (error == NULL, "%s", error->message); run_search (folder, 50); g_clear_error (&error); pull (); pull (); push ("closing and re-opening folder"); check_unref (folder, 1); folder = camel_store_get_folder_sync ( store, "testbox", flags & ~(CAMEL_STORE_FOLDER_CREATE), NULL, &error); check_msg (error == NULL, "%s", error->message); check (folder != NULL); g_clear_error (&error); push ("deleting remaining messages"); uids = camel_folder_get_uids (folder); check (uids->len == 50); for (j = 0; j < uids->len; j++) { camel_folder_delete_message (folder, uids->pdata[j]); } camel_folder_free_uids (folder, uids); run_search (folder, 50); push ("syncing"); camel_folder_synchronize_sync ( folder, FALSE, NULL, &error); check_msg (error == NULL, "%s", error->message); run_search (folder, 50); g_clear_error (&error); pull (); push ("expunging"); camel_folder_expunge_sync (folder, NULL, &error); check_msg (error == NULL, "%s", error->message); run_search (folder, 0); g_clear_error (&error); pull (); pull (); check_unref (folder, 1); pull (); push ("deleting test folder, with no messages in it"); camel_store_delete_folder_sync ( store, "testbox", NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); pull (); check_unref (store, 1); camel_test_end (); } } check_unref (session, 1); return 0; }
gint main (gint argc, gchar **argv) { CamelFolder *f1, *f2; CamelStore *store; CamelService *service; CamelFolderInfo *fi; GError *error = NULL; camel_test_init (argc, argv); camel_test_provider_init (1, local_drivers); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); service = camel_session_add_service ( session, "test-uid", "maildir:///tmp/camel-test/maildir", CAMEL_PROVIDER_STORE, NULL); store = CAMEL_STORE (service); camel_test_start ("Maildir backward compatability tests"); camel_test_push ("./ prefix path, one level"); f1 = camel_store_get_folder_sync ( store, "testbox", CAMEL_STORE_FOLDER_CREATE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); f2 = camel_store_get_folder_sync ( store, "./testbox", CAMEL_STORE_FOLDER_CREATE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (f1 == f2); check_unref (f2, 2); check_unref (f1, 1); camel_test_pull (); camel_test_push ("./ prefix path, one level, no create"); f1 = camel_store_get_folder_sync ( store, "testbox2", CAMEL_STORE_FOLDER_CREATE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); f2 = camel_store_get_folder_sync ( store, "./testbox2", 0, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (f1 == f2); check_unref (f2, 2); check_unref (f1, 1); camel_test_pull (); camel_test_push ("./ prefix path, two levels"); f1 = camel_store_get_folder_sync ( store, "testbox/foo", CAMEL_STORE_FOLDER_CREATE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); f2 = camel_store_get_folder_sync ( store, "./testbox/foo", CAMEL_STORE_FOLDER_CREATE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (f1 == f2); check_unref (f2, 2); check_unref (f1, 1); camel_test_pull (); camel_test_push ("'.' == Inbox"); f2 = camel_store_get_inbox_folder_sync (store, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); f1 = camel_store_get_folder_sync (store, ".", 0, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (f1 == f2); check_unref (f2, 2); check_unref (f1, 1); camel_test_pull (); camel_test_push ("folder info, recursive"); fi = camel_store_get_folder_info_sync ( store, "", CAMEL_STORE_FOLDER_INFO_RECURSIVE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (fi != NULL); check_fi (fi, fi_list_1, G_N_ELEMENTS (fi_list_1)); camel_test_pull (); camel_test_push ("folder info, flat"); fi = camel_store_get_folder_info_sync (store, "", 0, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (fi != NULL); check_fi (fi, fi_list_2, G_N_ELEMENTS (fi_list_2)); camel_test_pull (); camel_test_push ("folder info, recursive, non root"); fi = camel_store_get_folder_info_sync ( store, "testbox", CAMEL_STORE_FOLDER_INFO_RECURSIVE, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check (fi != NULL); check_fi (fi, fi_list_3, G_N_ELEMENTS (fi_list_3)); camel_test_pull (); check_unref (store, 1); check_unref (session, 1); camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { CamelSession *session; CamelSMimeContext *ctx; GError **error; CamelCipherValidity *valid; CamelStream *stream1, *stream2, *stream3; GPtrArray *recipients; GByteArray *buf; gchar *before, *after; camel_test_init (argc, argv); ex = camel_exception_new (); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); ctx = camel_smime_context_new (session); camel_test_start ("Test of S/MIME PKCS7 functions"); stream1 = camel_stream_mem_new (); camel_stream_write (stream1, "Hello, I am a test stream.", 25); g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL); stream2 = camel_stream_mem_new (); camel_test_push ("PKCS7 signing"); camel_smime_sign (ctx, "*****@*****.**", CAMEL_CIPHER_HASH_SHA1, stream1, stream2, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); camel_test_pull (); camel_exception_clear (ex); camel_test_push ("PKCS7 verify"); g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL); g_seekable_seek (G_SEEKABLE (stream2), 0, G_SEEK_SET, NULL, NULL); valid = camel_smime_verify (ctx, CAMEL_CIPHER_HASH_SHA1, stream1, stream2, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); check_msg (camel_cipher_validity_get_valid (valid), "%s", camel_cipher_validity_get_description (valid)); camel_cipher_validity_free (valid); camel_test_pull (); g_object_unref (stream1); g_object_unref (stream2); stream1 = camel_stream_mem_new (); stream2 = camel_stream_mem_new (); stream3 = camel_stream_mem_new (); camel_stream_write (stream1, "Hello, I am a test of encryption/decryption.", 44); g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL); camel_exception_clear (ex); camel_test_push ("PKCS7 encrypt"); recipients = g_ptr_array_new (); g_ptr_array_add (recipients, "*****@*****.**"); camel_smime_encrypt (ctx, FALSE, "*****@*****.**", recipients, stream1, stream2, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); g_ptr_array_free (recipients, TRUE); camel_test_pull (); g_seekable_seek (G_SEEKABLE (stream2), 0, G_SEEK_SET, NULL, NULL); camel_exception_clear (ex); camel_test_push ("PKCS7 decrypt"); camel_smime_decrypt (ctx, stream2, stream3, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); buf = CAMEL_STREAM_MEM (stream1)->buffer; before = g_strndup (buf->data, buf->len); buf = CAMEL_STREAM_MEM (stream3)->buffer; after = g_strndup (buf->data, buf->len); check_msg (string_equal (before, after), "before = '%s', after = '%s'", before, after); g_free (before); g_free (after); camel_test_pull (); g_object_unref (ctx); g_object_unref (session); camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { CamelSession *session; gint i, j, index; gchar *path; CamelStore *store; CamelService *service; GThread *threads[MAX_THREADS]; struct _threadinfo *info; CamelFolder *folder; GPtrArray *uids; GError *error = NULL; camel_test_init (argc, argv); camel_test_provider_init (1, local_drivers); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); session = camel_test_session_new ("/tmp/camel-test"); for (j = 0; j < G_N_ELEMENTS (local_providers); j++) { for (index = 0; index < 2; index++) { gchar *uid; path = g_strdup_printf ("method %s %s", local_providers[j], index?"indexed":"nonindexed"); camel_test_start (path); test_free (path); push ("trying %s index %d", local_providers[j], index); uid = g_strdup_printf ("test-uid-%d", j); path = g_strdup_printf ("%s:///tmp/camel-test/%s", local_providers[j], local_providers[j]); service = camel_session_add_service ( session, uid, path, CAMEL_PROVIDER_STORE, &error); g_free (uid); check_msg (error == NULL, "%s", error->message); check (CAMEL_IS_STORE (service)); store = CAMEL_STORE (service); test_free (path); if (index == 0) folder = camel_store_get_folder_sync ( store, "testbox", CAMEL_STORE_FOLDER_CREATE, NULL, &error); else folder = camel_store_get_folder_sync ( store, "testbox", CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_FOLDER_BODY_INDEX, NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); for (i = 0; i < MAX_THREADS; i++) { GError *error = NULL; info = g_malloc (sizeof (*info)); info->id = i * MAX_MESSAGES; info->folder = folder; threads[i] = g_thread_try_new (NULL, worker, info, &error); check_msg (error == NULL, "g_thread_try_new() failed: %s", error->message); } for (i = 0; i < MAX_THREADS; i++) { if (threads[i]) { info = g_thread_join (threads[i]); g_free (info); } } pull (); push ("deleting remaining messages"); uids = camel_folder_get_uids (folder); for (i = 0; i < uids->len; i++) { camel_folder_delete_message (folder, uids->pdata[i]); } camel_folder_free_uids (folder, uids); camel_folder_expunge_sync (folder, NULL, &error); check_msg (error == NULL, "%s", error->message); check_unref (folder, 1); camel_store_delete_folder_sync ( store, "testbox", NULL, &error); check_msg (error == NULL, "%s", error->message); g_clear_error (&error); check_unref (store, 1); pull (); camel_test_end (); } } g_object_unref (session); return 0; }
gint main (gint argc, gchar **argv) { CamelSession *session; CamelCipherContext *ctx; GError **error; CamelCipherValidity *valid; CamelMimePart *mime_part; CamelMultipartSigned *mps; CamelMultipartEncrypted *mpe; GPtrArray *recipients; gint ret; camel_test_init (argc, argv); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); system ("/bin/mkdir /tmp/camel-test"); setenv ("GNUPGHOME", "/tmp/camel-test/.gnupg", 1); /* import the gpg keys */ if ((ret = system ("gpg < /dev/null > /dev/null 2>&1")) == -1) return 77; else if (WEXITSTATUS (ret) == 127) return 77; system ("gpg --import ../data/camel-test.gpg.pub > /dev/null 2>&1"); system ("gpg --import ../data/camel-test.gpg.sec > /dev/null 2>&1"); session = camel_pgp_session_new ("/tmp/camel-test"); ex = camel_exception_new (); ctx = camel_gpg_context_new (session); camel_gpg_context_set_always_trust (CAMEL_GPG_CONTEXT (ctx), TRUE); camel_test_start ("Test of PGP/MIME functions"); mime_part = camel_mime_part_new (); camel_mime_part_set_content (mime_part, test_msg, strlen (test_msg), "text/plain"); camel_mime_part_set_description (mime_part, "Test of PGP/MIME multipart/signed stuff"); camel_test_push ("PGP/MIME signing"); mps = camel_multipart_signed_new (); camel_multipart_signed_sign (mps, ctx, mime_part, "*****@*****.**", CAMEL_CIPHER_HASH_SHA1, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); camel_test_pull (); g_object_unref (mime_part); camel_exception_clear (ex); camel_test_push ("PGP/MIME verify"); valid = camel_multipart_signed_verify (mps, ctx, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); check_msg (camel_cipher_validity_get_valid (valid), "%s", camel_cipher_validity_get_description (valid)); camel_cipher_validity_free (valid); camel_test_pull (); g_object_unref (mps); camel_exception_clear (ex); mime_part = camel_mime_part_new (); camel_mime_part_set_content (mime_part, test_msg, strlen (test_msg), "text/plain"); camel_mime_part_set_description (mime_part, "Test of PGP/MIME multipart/encrypted stuff"); camel_test_push ("PGP/MIME encrypt"); recipients = g_ptr_array_new (); g_ptr_array_add (recipients, "*****@*****.**"); mpe = camel_multipart_encrypted_new (); camel_multipart_encrypted_encrypt (mpe, mime_part, ctx, "*****@*****.**", recipients, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); g_ptr_array_free (recipients, TRUE); camel_test_pull (); camel_exception_clear (ex); g_object_unref (mime_part); camel_test_push ("PGP/MIME decrypt"); mime_part = camel_multipart_encrypted_decrypt (mpe, ctx, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); g_object_unref (mime_part); g_object_unref (mpe); camel_test_pull (); g_object_unref (ctx); g_object_unref (session); camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { gint i; CamelInternetAddress *addr, *addr2; gchar *name; const gchar *charset; const gchar *real, *where; gchar *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", "*****@*****.**"); 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, "*****@*****.**") == 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++) { gchar 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, "*****@*****.**", &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, "[email protected] ", &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 < G_N_ELEMENTS (test_lines); i++) { push ("Testing text line %d (%s) '%s'", i, test_lines[i].type, test_lines[i].line); addr = camel_internet_address_new (); /* first, convert to api format (utf-8) */ charset = test_lines[i].type; name = to_utf8 (test_lines[i].line, charset); push ("Address setup"); camel_internet_address_add (addr, name, "*****@*****.**"); check (camel_internet_address_get (addr, 0, &real, &where) == TRUE); check_msg (string_equal (name, real), "name = '%s' real = '%s'", name, real); check (strcmp (where, "*****@*****.**") == 0); test_free (name); check (camel_internet_address_get (addr, 1, &real, &where) == FALSE); check (camel_address_length (CAMEL_ADDRESS (addr)) == 1); pull (); push ("Address encode/decode"); enc = camel_address_encode (CAMEL_ADDRESS (addr)); addr2 = camel_internet_address_new (); check (camel_address_decode (CAMEL_ADDRESS (addr2), enc) == 1); check (camel_address_length (CAMEL_ADDRESS (addr2)) == 1); enc2 = camel_address_encode (CAMEL_ADDRESS (addr2)); check_msg (string_equal (enc, enc2), "enc = '%s' enc2 = '%s'", enc, enc2); test_free (enc2); push ("Compare addresses"); test_address_compare (addr, addr2); pull (); check_unref (addr2, 1); test_free (enc); pull (); /* FIXME: format/unformat arne't guaranteed to be reversible, at least at the moment */ camel_test_nonfatal ("format/unformat not (yet) reversible for all cases"); push ("Address format/unformat"); format = camel_address_format (CAMEL_ADDRESS (addr)); addr2 = camel_internet_address_new (); check (camel_address_unformat (CAMEL_ADDRESS (addr2), format) == 1); check (camel_address_length (CAMEL_ADDRESS (addr2)) == 1); format2 = camel_address_format (CAMEL_ADDRESS (addr2)); check_msg (string_equal (format, format2), "format = '%s\n\tformat2 = '%s'", format, format2); test_free (format2); /* currently format/unformat doesn't handle ,'s and other special chars at all */ if (camel_address_length (CAMEL_ADDRESS (addr2)) == 1) { push ("Compare addresses"); test_address_compare (addr, addr2); pull (); } test_free (format); pull (); camel_test_fatal (); check_unref (addr2, 1); check_unref (addr, 1); pull (); } camel_test_end (); camel_test_start ("CamelInternetAddress, I18N decode"); for (i = 0; i < G_N_ELEMENTS (test_address); i++) { push ("Testing address line %d '%s'", i, test_address[i].addr); addr = camel_internet_address_new (); push ("checking decoded"); check (camel_address_decode (CAMEL_ADDRESS (addr), test_address[i].addr) == test_address[i].count); format = camel_address_format (CAMEL_ADDRESS (addr)); check (strcmp (format, test_address[i].utf8) == 0); test_free (format); pull (); push ("Comparing re-encoded output"); addr2 = CAMEL_INTERNET_ADDRESS (camel_internet_address_new ()); enc = camel_address_encode (CAMEL_ADDRESS (addr)); check_msg (camel_address_decode (CAMEL_ADDRESS (addr2), enc) == test_address[i].count, "enc = '%s'", enc); test_free (enc); test_address_compare (addr, addr2); check_unref (addr2, 1); pull (); check_unref (addr, 1); pull (); } camel_test_end (); camel_test_start ("CamelInternerAddress name & email decoder"); for (i = 0; i < G_N_ELEMENTS (test_decode); i++) { gchar *line; const gchar *name, *email; gint jj; name = test_decode[i].name; email = test_decode[i].email; for (jj = 0; jj < G_N_ELEMENTS (line_decode_formats); jj++) { if (line_decode_formats[jj].without_name) { line = g_strdup_printf (line_decode_formats[jj].without_name, email); check_address_line_decode (i, line, NULL, email); g_free (line); } if (!name) continue; line = g_strdup_printf (line_decode_formats[jj].with_name, name, email); check_address_line_decode (i, line, name, email); g_free (line); } } camel_test_end (); return 0; }
gint main (gint argc, gchar **argv) { CamelStream *source; CamelStream *correct; CamelStream *stream; CamelMimeFilter *sh; gchar *work; gint i; gssize comp_progress, comp_correct_chunk, comp_filter_chunk; gint comp_i; gchar comp_correct[CHUNK_SIZE], comp_filter[CHUNK_SIZE]; camel_test_init (argc, argv); for (i = 0; i < NUM_CASES; i++) { gint j; work = g_strdup_printf ("CRLF/DOT filter, test case %d", i); camel_test_start (work); g_free (work); for (j = CRLF_ENCODE; j < CRLF_DONE; j++) { CamelMimeFilterCRLFDirection direction; gchar *infile = NULL, *outfile = NULL; switch (j) { case CRLF_ENCODE: camel_test_push ("Test of the encoder"); direction = CAMEL_MIME_FILTER_CRLF_ENCODE; infile = g_strdup_printf ("%s/crlf-%d.in", SOURCEDIR, i + 1); outfile = g_strdup_printf ("%s/crlf-%d.out", SOURCEDIR, i + 1); break; case CRLF_DECODE: camel_test_push ("Test of the decoder"); direction = CAMEL_MIME_FILTER_CRLF_DECODE; infile = g_strdup_printf ("%s/crlf-%d.out", SOURCEDIR, i + 1); outfile = g_strdup_printf ("%s/crlf-%d.in", SOURCEDIR, i + 1); break; default: break; } camel_test_push ("Initializing objects"); source = camel_stream_fs_new_with_name (infile, 0, O_RDONLY, NULL); if (!source) { camel_test_fail ("Failed to open input case in \"%s\"", infile); g_free (infile); continue; } g_free (infile); correct = camel_stream_fs_new_with_name (outfile, 0, O_RDONLY, NULL); if (!correct) { camel_test_fail ("Failed to open correct output in \"%s\"", outfile); g_free (outfile); continue; } g_free (outfile); stream = camel_stream_filter_new (source); if (!stream) { camel_test_fail ("Couldn't create CamelStreamFilter??"); continue; } sh = camel_mime_filter_crlf_new (direction, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS); if (!sh) { camel_test_fail ("Couldn't create CamelMimeFilterCrlf??"); continue; } camel_stream_filter_add ( CAMEL_STREAM_FILTER (stream), sh); camel_test_pull (); camel_test_push ("Running filter and comparing to correct result"); comp_progress = 0; while (1) { comp_correct_chunk = camel_stream_read ( correct, comp_correct, CHUNK_SIZE, NULL, NULL); comp_filter_chunk = 0; if (comp_correct_chunk == 0) break; while (comp_filter_chunk < comp_correct_chunk) { gssize delta; delta = camel_stream_read ( stream, comp_filter + comp_filter_chunk, CHUNK_SIZE - comp_filter_chunk, NULL, NULL); if (delta == 0) { camel_test_fail ("Chunks are different sizes: correct is %d, " "filter is %d, %d bytes into stream", comp_correct_chunk, comp_filter_chunk, comp_progress); } comp_filter_chunk += delta; } for (comp_i = 0; comp_i < comp_filter_chunk; comp_i++) { if (comp_correct[comp_i] != comp_filter[comp_i]) { camel_test_fail ("Difference: correct is %c, filter is %c, " "%d bytes into stream", comp_correct[comp_i], comp_filter[comp_i], comp_progress + comp_i); } } comp_progress += comp_filter_chunk; } camel_test_pull (); /* inefficient */ camel_test_push ("Cleaning up"); g_object_unref (stream); g_object_unref (correct); g_object_unref (source); g_object_unref (sh); camel_test_pull (); camel_test_pull (); } camel_test_end (); } return 0; }
int main (int argc, char **argv) { CamelSession *session; CamelCipherContext *ctx; CamelException *ex; CamelCipherValidity *valid; CamelStream *stream1, *stream2; struct _CamelMimePart *sigpart, *conpart, *encpart, *outpart; CamelDataWrapper *dw; GPtrArray *recipients; GByteArray *buf; char *before, *after; int ret; if (getenv("CAMEL_TEST_GPG") == NULL) return 77; camel_test_init (argc, argv); /* clear out any camel-test data */ system ("/bin/rm -rf /tmp/camel-test"); system ("/bin/mkdir /tmp/camel-test"); setenv ("GNUPGHOME", "/tmp/camel-test/.gnupg", 1); /* import the gpg keys */ if ((ret = system ("gpg < /dev/null > /dev/null 2>&1")) == -1) return 77; else if (WEXITSTATUS (ret) == 127) return 77; g_message ("gpg --import " TEST_DATA_DIR "/camel-test.gpg.pub > /dev/null 2>&1"); system ("gpg --import " TEST_DATA_DIR "/camel-test.gpg.pub > /dev/null 2>&1"); g_message ("gpg --import " TEST_DATA_DIR "/camel-test.gpg.sec > /dev/null 2>&1"); system ("gpg --import " TEST_DATA_DIR "/camel-test.gpg.sec > /dev/null 2>&1"); session = camel_pgp_session_new ("/tmp/camel-test"); ex = camel_exception_new (); ctx = camel_gpg_context_new (session); camel_gpg_context_set_always_trust (CAMEL_GPG_CONTEXT (ctx), TRUE); camel_test_start ("Test of PGP functions"); stream1 = camel_stream_mem_new (); camel_stream_write (stream1, "Hello, I am a test stream.\n", 27); camel_stream_reset (stream1); conpart = camel_mime_part_new(); dw = camel_data_wrapper_new(); camel_data_wrapper_construct_from_stream(dw, stream1); camel_medium_set_content_object((CamelMedium *)conpart, dw); camel_object_unref(stream1); camel_object_unref(dw); sigpart = camel_mime_part_new(); camel_test_push ("PGP signing"); camel_cipher_sign (ctx, "*****@*****.**", CAMEL_CIPHER_HASH_SHA1, conpart, sigpart, ex); if (camel_exception_is_set(ex)) { printf("PGP signing failed assuming non-functional environment\n%s", camel_exception_get_description (ex)); camel_test_pull(); return 77; } camel_test_pull (); camel_exception_clear (ex); camel_test_push ("PGP verify"); valid = camel_cipher_verify (ctx, sigpart, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); check_msg (camel_cipher_validity_get_valid (valid), "%s", camel_cipher_validity_get_description (valid)); camel_cipher_validity_free (valid); camel_test_pull (); camel_object_unref(conpart); camel_object_unref(sigpart); stream1 = camel_stream_mem_new (); camel_stream_write (stream1, "Hello, I am a test of encryption/decryption.", 44); camel_stream_reset (stream1); conpart = camel_mime_part_new(); dw = camel_data_wrapper_new(); camel_stream_reset(stream1); camel_data_wrapper_construct_from_stream(dw, stream1); camel_medium_set_content_object((CamelMedium *)conpart, dw); camel_object_unref(stream1); camel_object_unref(dw); encpart = camel_mime_part_new(); camel_exception_clear (ex); camel_test_push ("PGP encrypt"); recipients = g_ptr_array_new (); g_ptr_array_add (recipients, "*****@*****.**"); camel_cipher_encrypt (ctx, "*****@*****.**", recipients, conpart, encpart, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); g_ptr_array_free (recipients, TRUE); camel_test_pull (); camel_exception_clear (ex); camel_test_push ("PGP decrypt"); outpart = camel_mime_part_new(); valid = camel_cipher_decrypt (ctx, encpart, outpart, ex); check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex)); check_msg (valid->encrypt.status == CAMEL_CIPHER_VALIDITY_ENCRYPT_ENCRYPTED, "%s", valid->encrypt.description); stream1 = camel_stream_mem_new(); stream2 = camel_stream_mem_new(); camel_data_wrapper_write_to_stream((CamelDataWrapper *)conpart, stream1); camel_data_wrapper_write_to_stream((CamelDataWrapper *)outpart, stream2); buf = CAMEL_STREAM_MEM (stream1)->buffer; before = g_strndup (buf->data, buf->len); buf = CAMEL_STREAM_MEM (stream2)->buffer; after = g_strndup (buf->data, buf->len); check_msg (string_equal (before, after), "before = '%s', after = '%s'", before, after); g_free (before); g_free (after); camel_object_unref(stream1); camel_object_unref(stream2); camel_object_unref(conpart); camel_object_unref(encpart); camel_object_unref(outpart); camel_test_pull (); camel_object_unref (CAMEL_OBJECT (ctx)); camel_object_unref (CAMEL_OBJECT (session)); camel_test_end (); return 0; }