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;
}
static void *
worker(void *d)
{
	int i;
	CamelException *ex = camel_exception_new();
	CamelStore *store;
	CamelFolder *folder;

	for (i=0;i<MAX_LOOP;i++) {
		store = camel_session_get_store(session, path, ex);
		camel_exception_clear(ex);
		folder = camel_store_get_folder(store, "testbox", CAMEL_STORE_FOLDER_CREATE, ex);
		camel_exception_clear(ex);
		if (testid == 0) {
			camel_object_unref(folder);
			camel_object_unref(store);
		} else {
			camel_object_unref(store);
			camel_object_unref(folder);
		}
	}

	camel_exception_free(ex);

	return NULL;
}
Esempio n. 3
0
/**
 * mail_importer_add_line:
 * importer: A MailImporter structure.
 * str: Next line of the mbox.
 * finished: TRUE if @str is the last line of the message.
 *
 * Adds lines to the message until it is finished, and then adds
 * the complete message to the folder.
 */
void
mail_importer_add_line (MailImporter *importer,
			const char *str,
			gboolean finished)
{
	CamelMimeMessage *msg;
	CamelMessageInfo *info;
	CamelException *ex;

	if (importer->mstream == NULL)
		importer->mstream = CAMEL_STREAM_MEM (camel_stream_mem_new ());

	camel_stream_write (CAMEL_STREAM (importer->mstream), str,  strlen (str));

	if (finished == FALSE)
		return;

	camel_stream_reset (CAMEL_STREAM (importer->mstream));
	info = camel_message_info_new(NULL);
	camel_message_info_set_flags(info, CAMEL_MESSAGE_SEEN, ~0);

	msg = camel_mime_message_new ();
	camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg),
						  CAMEL_STREAM (importer->mstream));

	camel_object_unref (importer->mstream);
	importer->mstream = NULL;

	ex = camel_exception_new ();
	camel_folder_append_message (importer->folder, msg, info, NULL, ex);
	camel_object_unref (msg);

	camel_exception_free (ex);
	camel_message_info_free(info);
}
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)
{
	CamelSession *session;
	CamelException *ex;
	int i;
	char *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");

	ex = camel_exception_new();

	session = camel_test_session_new ("/tmp/camel-test");

	for (i=0;i<ARRAY_LEN(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);
	camel_exception_free(ex);

	return 0;
}
int main(int argc, char **argv)
{
    CamelSession *session;
    CamelStore *store;
    CamelException *ex;
    CamelFolder *folder;
    CamelMimeMessage *msg;
    int i, j;
    CamelStream *mbox;
    CamelFilterDriver *driver;

    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");

    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");
    store = camel_session_get_store(session, "mbox:///tmp/camel-test/mbox", ex);
    check_msg(!camel_exception_is_set(ex), "getting store: %s", camel_exception_get_description(ex));
    check(store != NULL);
    pull();

    push("Creating output folders");
    for (i=0; i<ARRAY_LEN(mailboxes); i++) {
        push("creating %s", mailboxes[i].name);
        mailboxes[i].folder = folder = camel_store_get_folder(store, mailboxes[i].name, CAMEL_STORE_FOLDER_CREATE, ex);
        check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
        check(folder != NULL);

        /* we need an empty folder for this to work */
        test_folder_counts(folder, 0, 0);
        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);
    for (j=0; j<100; j++) {
        char *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_printf(mbox, "From \n");
        check(camel_data_wrapper_write_to_stream((CamelDataWrapper *)msg, mbox) != -1);
#if 0
        push("appending simple message %d", j);
        camel_folder_append_message(folder, msg, NULL, ex);
        check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
        pull();
#endif
        test_free(subject);

        check_unref(msg, 1);
    }
    check(camel_stream_close(mbox) != -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<ARRAY_LEN(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);
    camel_filter_driver_filter_mbox(driver, "/tmp/camel-test/inbox", NULL, ex);
    check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));

    /* now need to check the folder counts/etc */

    check_unref(driver, 1);
    pull();

    /* this tests that invalid rules are caught */
    push("Testing broken match rules");
    for (i=0; i<ARRAY_LEN(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);
        camel_filter_driver_filter_mbox(driver, "/tmp/camel-test/inbox", NULL, ex);
        check(camel_exception_is_set(ex));
        camel_exception_clear(ex);
        check_unref(driver, 1);
        pull();
    }
    pull();

    push("Testing broken action rules");
    for (i=0; i<ARRAY_LEN(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);
        camel_filter_driver_filter_mbox(driver, "/tmp/camel-test/inbox", NULL, ex);
        check(camel_exception_is_set(ex));
        camel_exception_clear(ex);
        check_unref(driver, 1);
        pull();
    }
    pull();


    for (i=0; i<ARRAY_LEN(mailboxes); i++) {
        check_unref(mailboxes[i].folder, 1);
    }

    check_unref(store, 1);

    check_unref(session, 1);
    camel_exception_free(ex);

    camel_test_end();

    return 0;
}