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