Add tests.

2000-11-24  Not Zed  <NotZed@HelixCode.com>

	* Makefile.am (SUBDIRS): Add tests.

	* camel-mime-filter-basic.c (filter): Well, I'll add the extra
	bytes here too, lathough not strictly needed, might save a
	re-malloc when we get to complete().

	* camel-mime-filter-charset.c (filter): Make sure we have room if
	we only convert very short data.
	(complete): and here too.

	* tests/Makefile.am: Initial test harness & tests.  Requires gcc
	for this.

	* camel-internet-address.c (d): Turn off debug.

	* camel-charset-map.c (camel_charset_step): Oops, & masks for set
	intersection, not | them.  Dunno how this got even close to
	working.

2000-11-23  Not Zed  <NotZed@HelixCode.com>

	* camel-mime-filter-basic.c (filter): For base64 encoding, the
	output size for 0, 1, or 2 bytes of input can exceed input*2, so
	make sure we account for that as well.
	(complete): And here.
	(complete): Similarly for qp encoding, if we have a trailing
	space, we need some extra bytes (not needed for 'filter()', as any
	such bytes are stored in state/save).

	* camel-mime-utils.c (quoted_decode_step): Removed fixme not required.
	(quoted_encode_close): Dont append a trailing afterall.  Otherwise
	a pass through the encode/decode will grow the message each time.

svn path=/trunk/; revision=6656

1 files changed, 240 insertions, 0 deletions

diff --git a/camel/tests/lib/camel-test.c b/camel/tests/lib/camel-test.c
new file mode 100644
index 0000000000..b60ba1fb34
--- /dev/null
+++ b/camel/tests/lib/camel-test.c
@@ -0,0 +1,240 @@
+
+#include "camel-test.h"
+
+#include <stdio.h>
+#include <signal.h>
+
+struct _stack {
+	struct _stack *next;
+	char *what;
+};
+
+static int setup;
+static struct _stack *state;
+static struct _stack *nonfatal;
+static int ok;
+
+int camel_test_verbose;
+
+static void die(int sig)
+{
+	static indie = 0;
+	struct _stack *node;
+
+	if (!indie) {
+		indie = 1;
+		printf("\n\nReceived fatal signal %d\n", sig);
+		node = state;
+		if (node) {
+			printf("Current action:\n");
+			while (node) {
+				printf("\t%s\n", node->what);
+				node = node->next;
+			}
+		}
+	}
+
+	_exit(1);
+}
+
+void camel_test_init(int argc, char **argv)
+{
+	void camel_init(void);
+	int i;
+
+	setup = 1;
+
+	camel_init();
+
+	/* yeah, we do need ot thread init, even though camel isn't compiled with enable threads */
+	g_thread_init(NULL);
+
+	signal(SIGSEGV, die);
+	signal(SIGABRT, die);
+
+	/* default, just say what, how well we did, unless fail, then abort */
+	camel_test_verbose = 1;
+
+	for (i=0;i<argc;i++) {
+		if (argv[i][0] == '-') {
+			switch (argv[i][1]) {
+			case 'v':
+				camel_test_verbose = strlen(argv[i]);
+				break;
+			case 'q':
+				camel_test_verbose = 0;
+				break;
+			}
+		}
+	}
+}
+
+void camel_test_start(const char *what)
+{
+	if (!setup)
+		camel_test_init(0, 0);
+
+	ok = 1;
+
+	if (camel_test_verbose > 0) {
+		printf("Test: %s ... ", what);
+		fflush(stdout);
+	}
+}
+
+void camel_test_push(const char *what, ...)
+{
+	struct _stack *node;
+	va_list ap;
+	char *text;
+
+	va_start(ap, what);
+	text = g_strdup_vprintf(what, ap);
+	va_end(ap);
+
+	if (camel_test_verbose > 3)
+		printf("Start step: %s\n", text);
+
+	node = g_malloc(sizeof(*node));
+	node->what = text;
+	node->next = state;
+	state = node;
+}
+
+void camel_test_pull(void)
+{
+	struct _stack *node;
+
+	g_assert(state);
+
+	if (camel_test_verbose > 3)
+		printf("Finish step: %s\n", state->what);
+
+	node = state;
+	state = node->next;
+	g_free(node->what);
+	g_free(node);
+}
+
+void camel_test_fail(const char *why, ...)
+{
+	struct _stack *node;
+	va_list ap;
+	char *text;
+
+	va_start(ap, why);
+	text = g_strdup_vprintf(why, ap);
+	va_end(ap);
+
+	if ((nonfatal == NULL && camel_test_verbose > 0)
+	    || (nonfatal && camel_test_verbose > 1)) {
+		printf("Failed: %s\n", text);
+	}
+
+	g_free(text);
+
+	if ((nonfatal == NULL && camel_test_verbose > 0)
+	    || (nonfatal && camel_test_verbose > 2)) {
+		node = state;
+		if (node) {
+			printf("Current action:\n");
+			while (node) {
+				printf("\t%s\n", node->what);
+				node = node->next;
+			}
+		}
+	}
+
+	if (nonfatal == NULL) {
+		exit(1);
+	} else {
+		ok=0;
+		if (camel_test_verbose > 1) {
+			printf("Known problem (ignored): %s\n", nonfatal->what);
+		}
+	}
+}
+
+void camel_test_nonfatal(const char *why, ...)
+{
+	struct _stack *node;
+	va_list ap;
+	char *text;
+
+	va_start(ap, why);
+	text = g_strdup_vprintf(why, ap);
+	va_end(ap);
+
+	if (camel_test_verbose>3)
+		printf("Start nonfatal: %s\n", text);
+
+	node = g_malloc(sizeof(*node));
+	node->what = text;
+	node->next = nonfatal;
+	nonfatal = node;
+}
+
+/* dont ask me why but the compiler just can't seem to find the prototypes for this */
+void camel_test_fatal()
+{
+	struct _stack *node;
+
+	g_assert(nonfatal);
+
+	if (camel_test_verbose>3)
+		printf("Finish nonfatal: %s\n", nonfatal->what);
+
+	node = nonfatal;
+	nonfatal = node->next;
+	g_free(node->what);
+	g_free(node);
+}
+
+void camel_test_end(void)
+{
+	if (camel_test_verbose > 0) {
+		if (ok)
+			printf("Ok\n");
+		else
+			printf("Partial success\n");
+	}
+
+	fflush(stdout);
+}
+
+
+
+
+/* compare strings, ignore whitespace though */
+int string_equal(const char *a, const char *b)
+{
+	const char *ap, *bp;
+	int cmp;
+
+	ap = a;
+	bp = b;
+
+	while (*ap && *bp) {
+		while (*ap == ' ' || *ap == '\n' || *ap == '\t')
+			ap++;
+		while (*bp == ' ' || *bp == '\n' || *bp == '\t')
+			bp++;
+
+		a = ap;
+		b = bp;
+
+		while (*ap && *ap != ' ' && *ap != '\n' && *ap != '\t')
+			ap++;
+		while (*bp && *bp != ' ' && *bp != '\n' && *bp != '\t')
+			bp++;
+
+		if (ap - a != bp - a
+		    && ap - 1 > 0
+		    && memcmp(a, b, ap-a) != 0) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+