httpd-apreq-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From j...@apache.org
Subject svn commit: r153577 - in httpd/apreq/trunk: CHANGES Makefile.am README t/CuTest.c t/CuTest.h t/Makefile.am t/README t/at.c t/at.h t/cookie.c t/params.c t/parsers.c t/test_apreq.h t/test_env.c t/testall.c t/version.c
Date Sat, 12 Feb 2005 23:04:39 GMT
Author: joes
Date: Sat Feb 12 15:04:35 2005
New Revision: 153577

URL: http://svn.apache.org/viewcvs?view=rev&rev=153577
Log:
  Replace CuTest-based tests with custom TAP-compliant
  framework.

Added:
    httpd/apreq/trunk/t/at.c
    httpd/apreq/trunk/t/at.h
    httpd/apreq/trunk/t/test_env.c
Removed:
    httpd/apreq/trunk/t/CuTest.c
    httpd/apreq/trunk/t/CuTest.h
    httpd/apreq/trunk/t/README
    httpd/apreq/trunk/t/testall.c
Modified:
    httpd/apreq/trunk/CHANGES
    httpd/apreq/trunk/Makefile.am
    httpd/apreq/trunk/README
    httpd/apreq/trunk/t/Makefile.am
    httpd/apreq/trunk/t/cookie.c
    httpd/apreq/trunk/t/params.c
    httpd/apreq/trunk/t/parsers.c
    httpd/apreq/trunk/t/test_apreq.h
    httpd/apreq/trunk/t/version.c

Modified: httpd/apreq/trunk/CHANGES
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/CHANGES?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/CHANGES (original)
+++ httpd/apreq/trunk/CHANGES Sat Feb 12 15:04:35 2005
@@ -5,6 +5,10 @@
 @section v2_05 Changes with libapreq2-2.05
 
 
+- C Tests [joes]
+  Replace CuTest-based tests with custom TAP-compliant
+  framework.
+
 - C API [joes]
   Make our "libtool current interface" number depend on apr's 
   major number.  This allows libapreq2 to be installed into a 

Modified: httpd/apreq/trunk/Makefile.am
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/Makefile.am?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/Makefile.am (original)
+++ httpd/apreq/trunk/Makefile.am Sat Feb 12 15:04:35 2005
@@ -78,13 +78,13 @@
 	-mkdir docs
 	echo GENERATE_TAGFILE=`pwd`/docs/apr.tag | $(APR_DOX)
 
-test: lib_test env_test $(PERL_TEST)
+test: all lib_test env_test $(PERL_TEST)
 
 env_test:
 	cd env; $(MAKE) test
 
-lib_test: check
-	t/testall -v
+lib_test:
+	cd t; $(MAKE) test
 
 perl_install:
 	cd glue/perl; $(MAKE) install

Modified: httpd/apreq/trunk/README
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/README?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/README (original)
+++ httpd/apreq/trunk/README Sat Feb 12 15:04:35 2005
@@ -112,10 +112,9 @@
   We wish to acknowledge the following copyrighted works that
   make up portions of the Apache software:
 
-  libapreq version 2 relies heavily on the use of GNU autoconf, 
-  automake and libtool to provide a build environment.  The core
-  unit tests for libapreq are based upon CuTest.  The environment
-  and perl glue tests are based on Apache::Test.  
+  libapreq2 relies heavily on the use of the GNU auto-tools 
+  to provide a build environment.  The tests are based on 
+  the Apache::Test, Test::Harness and Test::Inline.
 
-  Doxygen generates the documentation for libapreq-2. The perl glue
+  Doxygen generates the documentation for libapreq2. The perl glue
   and pods are generated by ExtUtils::XSBuilder.

Modified: httpd/apreq/trunk/t/Makefile.am
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/Makefile.am?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/t/Makefile.am (original)
+++ httpd/apreq/trunk/t/Makefile.am Sat Feb 12 15:04:35 2005
@@ -2,11 +2,20 @@
 LIBS = ../src/libapreq2.la @APR_LTLIBS@ @APU_LTLIBS@
 LDFLAGS = @APR_LDFLAGS@ @APU_LDFLAGS@
 
-noinst_LIBRARIES = libapreq2_tests.a
-libapreq2_tests_a_SOURCES = CuTest.h test_apreq.h CuTest.c version.c cookie.c params.c parsers.c
+noinst_LIBRARIES = libapreq2_test.a
+libapreq2_test_a_SOURCES = at.h at.c test_env.c
 
-check_PROGRAMS = testall
-testall_LDADD  = libapreq2_tests.a
+check_PROGRAMS = version cookie params parsers
+LDADD  = libapreq2_test.a
 
-test:	check
-	./testall -v
+check_SCRIPTS = version.t cookie.t params.t parsers.t
+TESTS = $(check_SCRIPTS)
+TESTS_ENVIRONMENT = @PERL@ -MTest::Harness -e 'runtests(@ARGV)'
+CLEANFILES = $(check_SCRIPTS)
+
+%.t: %
+	echo "#!perl" > $@
+	echo "exec './$*'" >> $@
+
+test: $(check_SCRIPTS)
+	$(TESTS_ENVIRONMENT) $(check_SCRIPTS)

Added: httpd/apreq/trunk/t/at.c
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/at.c?view=auto&rev=153577
==============================================================================
--- httpd/apreq/trunk/t/at.c (added)
+++ httpd/apreq/trunk/t/at.c Sat Feb 12 15:04:35 2005
@@ -0,0 +1,338 @@
+/*
+**  Copyright 2004-2005  The Apache Software Foundation
+**
+**  Licensed under the Apache License, Version 2.0 (the "License");
+**  you may not use this file except in compliance with the License.
+**  You may obtain a copy of the License at
+**
+**      http://www.apache.org/licenses/LICENSE-2.0
+**
+**  Unless required by applicable law or agreed to in writing, software
+**  distributed under the License is distributed on an "AS IS" BASIS,
+**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+**  See the License for the specific language governing permissions and
+**  limitations under the License.
+*/
+
+#include "apr_file_io.h"
+#include "at.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_tables.h"
+#include "apr_env.h"
+#include <assert.h>
+
+
+apr_status_t at_begin(at_t *t, int total)
+{
+    char buf[32];
+    apr_snprintf(buf, 32, "1..%d", total);
+    return at_report(t, buf);
+}
+
+static apr_status_t test_cleanup(void *data)
+{
+    at_t *t = data;
+    if (t->current < t->plan)
+        return at_report(t, "Bail out!");
+    else
+        return at_report(t, "END"); 
+}
+
+void at_end(at_t *t)
+{     
+    apr_pool_cleanup_kill(t->pool, t, test_cleanup);
+    test_cleanup(t);
+}
+
+apr_status_t at_comment(at_t *t, const char *fmt, va_list vp)
+{
+    apr_status_t s;
+    char buf[256], *b = buf + 2;
+    char *end;
+    int rv;
+    rv = apr_vsnprintf(b, 250, fmt, vp);
+
+    if (rv <= 0)
+        return APR_EINVAL;
+
+    end = b + rv;
+
+    buf[0] = '#';
+    buf[1] = ' ';
+
+    if (rv == 250) {
+        *end++ = '.';
+        *end++ = '.';
+        *end++ = '.';
+        *end = '\n';
+    }
+    else if (end[-1] != '\n') {
+        *end = '\n';
+    }
+
+    b = buf;
+    while (1) {
+        char *eol;
+
+        eol = strchr(b + 2, '\n');
+        assert(eol != NULL);
+        *eol = 0;
+        s = at_report(t, b);
+        if (s != APR_SUCCESS || eol == end)
+            break;
+
+        b    = eol - 1;
+        b[0] = '#';
+        b[1] = ' ';
+    }
+
+    return s;
+} 
+
+void at_ok(at_t *t, int is_ok, const char *label, const char *file, int line)
+{
+    char format[] = "not ok %d - %s # %s (%s:%d) test %d in %s";
+    char *end = format + 10;
+    char *fmt = is_ok ? format + 4 : format;
+    char buf[256];
+    const char *comment = NULL;
+    int rv, is_fatal = 0, is_skip = 0, is_todo = 0;
+
+    t->current++;
+      
+    if (*t->fatal == t->current) {
+        t->fatal++;
+        is_fatal = 1;
+    }
+
+    if (*t->skip == t->current) {
+        t->skip++;
+        is_skip = 1;
+    }
+
+    if (*t->todo == t->current) {
+        t->todo++;
+        is_todo = 1;
+    }
+
+    if (AT_FLAG_CONCISE(t->flags))
+        format[9] = '\0';
+    else if (is_ok && !AT_FLAG_TRACE(t->flags))
+        format[14] = '\0';
+    else if (is_fatal && ! is_ok)
+        comment = "bail";
+    else
+        comment = is_todo ? "todo" : is_skip ? "skip" : "at";
+
+    rv = apr_snprintf(buf, 256, fmt, t->current + t->prior, 
+                      label, comment,  file, line, t->current, t->name);
+
+    if (rv <= 0)
+        exit(-1);
+
+    end = buf + rv;
+
+    if (rv == 250) {
+        *end++ = '.';
+        *end++ = '.';
+        *end++ = '.';
+        *end = '\0';
+    }
+
+    if (memchr(buf, '\n', rv) != NULL || at_report(t, buf) != APR_SUCCESS)
+        exit(-1);
+
+    if (!is_ok && is_fatal) {
+        if (t->abort != NULL) {
+            at_trace(t, "Abandon %s, omitting tests %d - %d from this run.",
+                     t->name, t->prior + t->current + 1, t->prior + t->plan);
+            longjmp(*t->abort, 0);
+        }
+        else {
+            apr_pool_cleanup_kill(t->pool, t, test_cleanup);
+            at_report(t, "Bail out!");
+            exit(-1);
+        }
+    }
+}
+
+struct at_report_file {
+    at_report_t module;
+    apr_file_t *file;
+};
+
+
+static apr_status_t at_report_file_write(at_report_t *ctx, const char *msg)
+{
+    struct at_report_file *r = (struct at_report_file *)ctx;
+    apr_file_t *f = r->file;
+    apr_size_t len = strlen(msg);
+    apr_status_t s;
+
+    s = apr_file_write_full(f, msg, len, &len);
+    if (s != APR_SUCCESS)
+        return s;
+
+    s = apr_file_putc('\n', f);
+    if (s != APR_SUCCESS)
+        return s;
+
+    return apr_file_flush(f);
+}
+
+at_report_t *at_report_file_make(apr_pool_t *p, apr_file_t *f)
+{
+    struct at_report_file *r = apr_palloc(p, sizeof *r);
+    r->module.func = at_report_file_write;
+    r->file = f;
+    return &r->module;
+}
+
+
+
+struct at_report_local {
+    at_report_t  module;
+    at_t        *t;
+    at_report_t *saved_report;
+    const int   *saved_fatal;
+    int          dummy_fatal;
+    const char  *file;
+    int          line;
+    int          passed;
+    apr_pool_t  *pool;
+};
+
+
+static apr_status_t report_local_cleanup(void *data)
+{
+    struct at_report_local *q = data;
+    dAT = q->t;
+    char label[32];
+
+    apr_snprintf(label, 32, "collected %d passing tests", q->passed);
+
+    AT->report = q->saved_report;
+    AT->fatal = q->saved_fatal;
+
+    at_ok(q->t, 1, label, q->file, q->line);
+    return APR_SUCCESS;
+}
+
+
+static apr_status_t at_report_local_write(at_report_t *ctx, const char *msg)
+{
+    struct at_report_local *q = (struct at_report_local *)ctx;
+    dAT = q->t;
+
+    if (strncmp(msg, "not ok", 6) == 0) {
+        q->saved_report->func(q->saved_report, msg);
+        AT->report = q->saved_report;
+        AT->fatal = q->saved_fatal;
+        apr_pool_cleanup_kill(q->pool, q, report_local_cleanup);
+        at_trace(AT, "Abandon %s, omitting tests %d - %d from this run.",
+                 AT->name, AT->prior + AT->current + 1, AT->prior + AT->plan);
+        longjmp(*AT->abort, 0);
+    }
+    AT->current--;
+    q->passed++;
+    return APR_SUCCESS;
+}
+
+void at_report_local(at_t *AT, apr_pool_t *p, const char *file, int line)
+{
+    struct at_report_local *q = apr_palloc(p, sizeof *q);
+    q->module.func = at_report_local_write;
+    q->t = AT;
+    q->saved_report = AT->report;
+    q->saved_fatal = AT->fatal;
+    q->dummy_fatal = 0;
+    q->file = apr_pstrdup(p, file);
+    q->line = line;
+    q->passed = 0;
+    q->pool = p;
+
+    AT->fatal = &q->dummy_fatal;
+    AT->report = &q->module;
+
+    if (*q->saved_fatal == AT->current + 1)
+        q->saved_fatal++;
+
+    apr_pool_cleanup_register(p, q, report_local_cleanup, 
+                                    report_local_cleanup);
+}
+
+
+at_t *at_create(apr_pool_t *pool, unsigned char flags, at_report_t *report)
+{
+    at_t *t = apr_pcalloc(pool, sizeof *t);
+    t->flags = flags;
+    t->report = report;
+    t->pool = pool;
+
+    apr_pool_cleanup_register(pool, t, test_cleanup, test_cleanup);
+    return t;
+}
+
+
+#define AT_NELTS 4
+
+static int* at_list(apr_pool_t *pool, const char *spec, int *list)
+{
+    apr_array_header_t arr;
+    int prev, current = 0;
+
+    arr.pool = pool;
+    arr.elt_size = sizeof *list;
+    arr.nelts = 0;
+    arr.nalloc = AT_NELTS;
+    arr.elts = (char *)list;
+
+    do {
+        while (*spec && !apr_isdigit(*spec))
+            ++spec;
+
+        prev = current;
+        current = (int)apr_strtoi64(spec, (char **)&spec, 10);
+        *(int *)apr_array_push(&arr) = current;
+
+    } while (prev >= current);
+
+    return (int *)arr.elts;
+}
+
+
+
+apr_status_t at_run(at_t *AT, const at_test_t *test)
+{
+    int dummy = 0, fbuf[AT_NELTS], sbuf[AT_NELTS], tbuf[AT_NELTS];
+    jmp_buf j;
+
+    AT->current = 0;
+    AT->prior   += AT->plan;
+    AT->name    = test->name;
+    AT->plan    = test->plan;
+
+    if (test->fatals)
+        AT->fatal = at_list(AT->pool, test->fatals, fbuf);
+    else
+        AT->fatal = &dummy;
+
+    if (test->skips)
+        AT->skip = at_list(AT->pool, test->skips, sbuf);
+    else
+        AT->skip = &dummy;
+
+    if (test->todos)
+        AT->todo = at_list(AT->pool, test->todos, tbuf);
+    else
+        AT->todo = &dummy;
+
+    AT->abort = &j;
+    if (setjmp(j) == 0) {
+        test->func(AT);
+        return APR_SUCCESS;
+    }
+    AT->abort = NULL;
+    return APR_EGENERAL;
+}

Added: httpd/apreq/trunk/t/at.h
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/at.h?view=auto&rev=153577
==============================================================================
--- httpd/apreq/trunk/t/at.h (added)
+++ httpd/apreq/trunk/t/at.h Sat Feb 12 15:04:35 2005
@@ -0,0 +1,265 @@
+/*
+**  Copyright 2004-2005  The Apache Software Foundation
+**
+**  Licensed under the Apache License, Version 2.0 (the "License");
+**  you may not use this file except in compliance with the License.
+**  You may obtain a copy of the License at
+**
+**      http://www.apache.org/licenses/LICENSE-2.0
+**
+**  Unless required by applicable law or agreed to in writing, software
+**  distributed under the License is distributed on an "AS IS" BASIS,
+**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+**  See the License for the specific language governing permissions and
+**  limitations under the License.
+*/
+
+
+/* at.h: TAP-compliant C utilities for the Apache::Test framework. */
+
+#ifndef AT_H
+#define AT_H
+
+#include "apr.h"
+#include "apr_file_io.h"
+#include <stdarg.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+typedef struct at_t at_t;
+typedef struct at_report_t at_report_t;
+
+typedef apr_status_t (*at_report_function_t)(at_report_t *r, const char *msg);
+typedef void(*at_test_function_t)(at_t *t);
+typedef struct at_test_t at_test_t;
+
+struct at_test_t {
+    const char          *name;
+    at_test_function_t   func;
+    int                  plan;
+    const char          *fatals;
+    const char          *todos;
+    const char          *skips;
+};
+
+struct at_report_t {
+    at_report_function_t func;
+};
+
+/* We only need one at_t struct per test suite, so lets call it *AT.
+ * The mnemonic we follow is that (for lowercase foo) "AT_foo(bar)" 
+ * should be syntactically equivalent to "at_foo(AT, bar)".
+ *
+ * Terminology: test == an at_test_t, 
+ *              check == an assertion which produces TAP.
+ */
+
+#define dAT at_t *AT
+
+struct at_t {
+    int                  current; /* current check for this test */
+    int                  prior;   /* total # of checks prior to this test */
+    const char          *name;    /* name of current test */
+    int                  plan;    /* total # of checks in this test */
+    const int           *fatal;   /* list of unrecoverables */
+    const int           *todo;    /* list of expected failures */
+    const int           *skip;    /* list of ignorabe assertions */
+    at_report_t         *report  ;/* handles the results of each check */
+    unsigned char        flags;   /* verbosity: concise, trace, debug, etc. */
+    apr_pool_t          *pool;    /* creator pool with end-of-test cleanup */
+    jmp_buf             *abort;   /* where fatals go to die */
+};
+
+
+
+static APR_INLINE
+apr_status_t at_report(at_t *t, const char *msg) { 
+    at_report_t *r = t->report;
+    return r->func(r, msg);
+}
+#define AT_report(msg) at_report(AT, msg)
+
+/* The core assertion checker; the rest just wind up invoking this one. */
+void at_ok(at_t *t, int is_ok, const char *label, const char *file, int line);
+#define AT_ok(is_ok, label) at_ok(AT, is_ok, label, __FILE__, __LINE__)
+
+at_t *at_create(apr_pool_t *pool, unsigned char flags, at_report_t *report);
+apr_status_t at_begin(at_t *t, int total);
+#define AT_begin(total) at_begin(AT, total)
+
+apr_status_t at_run(at_t *AT, const at_test_t *test);
+#define AT_run(test) at_run(AT, test)
+
+void at_end(at_t *t);
+#define AT_end() at_end(AT)
+
+
+#define AT_FLAG_DEBUG(f)       ((f) & 4)
+#define AT_FLAG_DEBUG_ON(f)    ((f) |= 4)
+#define AT_FLAG_DEBUG_OFF(f)   ((f) &= ~4)
+#define AT_FLAG_TRACE(f)       ((f) & 2)
+#define AT_FLAG_TRACE_ON(f)    ((f) |= 2)
+#define AT_FLAG_TRACE_OFF(f)   ((f) &= ~2)
+#define AT_FLAG_CONCISE(f)     ((f) & 1)
+#define AT_FLAG_CONCISE_ON(f)  ((f) |= 1)
+#define AT_FLAG_CONCISE_OFF(f) ((f) &= ~1)
+
+#define AT_debug_on()      AT_FLAG_DEBUG_ON(AT->flags)
+#define AT_debug_off()     AT_FLAG_DEBUG_OFF(AT->flags)
+#define AT_trace_on()      AT_FLAG_TRACE_ON(AT->flags)
+#define AT_trace_off()     AT_FLAG_TRACE_OFF(AT->flags)
+#define AT_concise_on()    AT_FLAG_CONCISE_ON(AT->flags)
+#define AT_concise_off()   AT_FLAG_CONCISE_OFF(AT->flags)
+
+
+
+/* Additional reporting utils. 
+   These emit TAP comments, and are not "checks". */
+
+apr_status_t at_comment(at_t *t, const char *fmt, va_list vp);
+
+static APR_INLINE
+void at_debug(at_t *t, const char *fmt, ...) {
+    va_list vp;
+    va_start(vp, fmt);
+    if (AT_FLAG_DEBUG(t->flags))
+        at_comment(t, fmt, vp);
+    va_end(vp);
+}
+
+static APR_INLINE
+void at_trace(at_t *t, const char *fmt, ...) {
+    va_list vp;
+    va_start(vp, fmt);
+    if (AT_FLAG_TRACE(t->flags))
+        at_comment(t, fmt, vp);
+    va_end(vp);
+}
+
+
+
+/* These are "checks". */
+
+static APR_INLINE
+void at_check(at_t *t, int is_ok, const char *label, const char *file,
+           int line, const char *fmt, ...)
+{
+    va_list vp;
+
+    va_start(vp, fmt);
+    if (AT_FLAG_TRACE(t->flags)) {
+        char format[64] = "testing: %s (%s:%d)";
+            at_trace(t, format, label, file, line);
+
+        if (fmt != NULL) {
+            char *f;
+            at_trace(t, " format: %s", fmt);
+            strcpy(format, "   left: ");
+            strcpy(format + sizeof("   left: ") -1, fmt);
+            f = format + strlen(format);
+            strcpy(f+1, format);
+            *f = '\n';
+            memcpy(f+1, "  right: ", sizeof("  right: ") -1);
+            at_comment(t, format, vp);
+        }
+    }
+    va_end(vp);
+    at_ok(t, is_ok, label, file, line);
+}
+
+
+#define AT_mem_ne(a, b, n) do {                                         \
+    unsigned sz = n;                                                    \
+    const void *left = a, *right = b;                                   \
+    char fmt[] =  ", as %u-byte struct pointers";                       \
+    char buf[256] = #a " != " #b;                                       \
+    const unsigned blen = sizeof(#a " != " #b);                         \
+    apr_snprintf(buf + blen - 1, 256 - blen, fmt, sz);                  \
+    apr_snprintf(fmt, sizeof(fmt), "%%.%us", sz);                       \
+    at_check(AT, memcmp(left, right, sz), buf, __FILE__, __LINE__,      \
+           fmt, left, right);                                           \
+} while (0)                                                             \
+
+#define AT_mem_eq(a, b, n) do {                                         \
+    unsigned sz = n;                                                    \
+    const void *left = a, *right = b;                                   \
+    char fmt[] =  ", as %u-byte struct pointers";                       \
+    char buf[256] = #a " == " #b;                                       \
+    const unsigned blen = sizeof(#a " == " #b);                         \
+    apr_snprintf(buf + blen - 1, 256 - blen , fmt, sz);                 \
+    apr_snprintf(fmt, sizeof(fmt), "%%.%us", sz);                       \
+    at_check(AT, !memcmp(left, right, sz), buf, __FILE__, __LINE__,     \
+           fmt, left, right);                                           \
+} while (0)
+
+
+
+#define AT_str_eq(a, b) do {                                            \
+    const char *left = a, *right = b;                                   \
+    at_check(AT,!strcmp(left, right), #a " == " #b ", as strings",      \
+            __FILE__, __LINE__, "%s", left, right);                     \
+} while (0)
+
+
+#define AT_str_ne(a, b) do {                                           \
+    const char *left = a, *right = b;                                  \
+    at_check(AT, strcmp(left, right), #a " != " #b ", as strings",     \
+            __FILE__, __LINE__, "%s", left, right);                    \
+} while (0)
+
+#define AT_ptr_eq(a, b) do {                                    \
+    const void *left = a, *right = b;                           \
+    at_check(AT, left == right, #a " == " #b ", as pointers",   \
+            __FILE__, __LINE__, "%pp", left, right);            \
+} while (0)
+
+#define AT_ptr_ne(a, b) do {                                    \
+    const void *left = a, *right = b;                           \
+    at_check(AT, left != right, #a " != " #b ", as pointers",   \
+            __FILE__, __LINE__, "%pp", left, right);            \
+} while (0)
+
+
+#define AT_int_eq(a, b) do {                                    \
+    const int left = a, right = b;                              \
+    at_check(AT, left == right, #a " == " #b ", as integers",   \
+            __FILE__, __LINE__, "%d", left, right);             \
+} while (0)
+
+#define AT_int_ne(a, b) do {                                    \
+    const int left = a, right = b;                              \
+    at_check(AT, left != right, #a " != " #b ", as integers",   \
+            __FILE__, __LINE__, "%d", left, right);             \
+} while (0)
+
+#define AT_is_null(a)  AT_ptr_eq(a, NULL)
+#define AT_not_null(a) AT_ptr_ne(a, NULL)
+
+
+/* XXX these two macro checks evaluate a & b more than once, but the 
+ * upshot is that they don't care too much about their types.
+ */
+
+#define AT_EQ(a, b, fmt) at_check(AT, ((a) == (b)), #a " == " #b,\
+                                  __FILE__, __LINE__, fmt, a, b)
+#define AT_NE(a, b, fmt) at_check(AT, ((a) != (b)), #a " != " #b,\
+                                  __FILE__, __LINE__, fmt, a, b)
+
+
+
+/* Report utilities. */
+
+at_report_t *at_report_file_make(apr_pool_t *p, apr_file_t *f);
+APR_INLINE
+static at_report_t *at_report_stdout_make(apr_pool_t *p)
+{
+    apr_file_t *out;
+    apr_file_open_stdout(&out, p);
+    return at_report_file_make(p, out);
+}
+
+void at_report_local(at_t *AT, apr_pool_t *p, const char *file, int line);
+#define AT_localize(p) at_report_local(AT, p, __FILE__, __LINE__)
+
+
+#endif /* AT_H */

Modified: httpd/apreq/trunk/t/cookie.c
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/cookie.c?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/t/cookie.c (original)
+++ httpd/apreq/trunk/t/cookie.c Sat Feb 12 15:04:35 2005
@@ -15,121 +15,137 @@
 */
 
 #include "apreq_env.h"
-#include "test_apreq.h"
-#include "apreq.h"
-#include "apreq_cookie.h"
 #include "apr_strings.h"
+#include "at.h"
 
+extern apr_pool_t *p;
 static apreq_jar_t *j = NULL;
 
-static void jar_make(CuTest *tc)
+#define dTEST(func, plan) static const at_test_t test_##func = \
+      {#func, func, plan, NULL, NULL, NULL}
+
+static void jar_make(dAT)
 {
     j = apreq_jar(p,"a=1; foo=bar; fl=left; fr=right;bad; ns=foo=1&bar=2,"
                   "frl=right-left; flr=left-right; fll=left-left; good_one=1;bad");
-    CuAssertPtrNotNull(tc, j);
+    AT_not_null(j);
 }
+dTEST(jar_make, 1);
+
 
-static void jar_table_get(CuTest *tc)
+static void jar_get(dAT)
 {
-    const char *val;
 
-    val = apr_table_get(j->cookies,"a");
-    CuAssertStrEquals(tc,"1",val);
+    AT_str_eq(apr_table_get(j->cookies,"a"), "1");
 
     /* ignore wacky cookies that don't have an '=' sign */
-    val = apr_table_get(j->cookies,"bad");
-    CuAssertPtrEquals(tc,NULL,val);
+    AT_is_null(apr_table_get(j->cookies,"bad"));
     /* accept wacky cookies that contain multiple '=' */
-    val = apr_table_get(j->cookies,"ns");
-    CuAssertStrEquals(tc,"foo=1&bar=2",val);
+    AT_str_eq(apr_table_get(j->cookies,"ns"), "foo=1&bar=2");
 
-    val = apr_table_get(j->cookies,"foo");
-    CuAssertStrEquals(tc,"bar",val);
-    val = apr_table_get(j->cookies,"fl");
-    CuAssertStrEquals(tc,"left",val);
-    val = apr_table_get(j->cookies,"fr");
-    CuAssertStrEquals(tc,"right",val);
-    val = apr_table_get(j->cookies,"frl");
-    CuAssertStrEquals(tc,"right-left",val);
-    val = apr_table_get(j->cookies,"flr");
-    CuAssertStrEquals(tc,"left-right",val);
-    val = apr_table_get(j->cookies,"fll");
-    CuAssertStrEquals(tc,"left-left",val);
+    AT_str_eq(apr_table_get(j->cookies,"foo"), "bar");
+    AT_str_eq(apr_table_get(j->cookies,"fl"), "left");
+    AT_str_eq(apr_table_get(j->cookies,"fr"), "right");
+    AT_str_eq(apr_table_get(j->cookies,"frl"),"right-left");
+    AT_str_eq(apr_table_get(j->cookies,"flr"),"left-right");
+    AT_str_eq(apr_table_get(j->cookies,"fll"),"left-left");
 }
+dTEST(jar_get, 9);
 
 
-static void netscape_cookie(CuTest *tc)
+static void netscape_cookie(dAT)
 {
     apreq_cookie_t *c;
-    apreq_cookie_version_t version = APREQ_COOKIE_VERSION_NETSCAPE;
-
+    char *one_year_expiration;
     c = apreq_cookie(j,"foo");
-    CuAssertStrEquals(tc,"bar",apreq_cookie_value(c));
-    CuAssertIntEquals(tc, version,c->version);
+    AT_str_eq(apreq_cookie_value(c), "bar");
+    AT_int_eq(c->version, APREQ_COOKIE_VERSION_NETSCAPE);
+    AT_str_eq(apreq_cookie_as_string(c,p), "foo=bar");
 
-    CuAssertStrEquals(tc,"foo=bar", apreq_cookie_as_string(c,p));
     c->domain = apr_pstrdup(p, "example.com");
-    CuAssertStrEquals(tc,"foo=bar; domain=example.com", 
-                      apreq_cookie_as_string(c,p));
+    AT_str_eq(apreq_cookie_as_string(c,p),
+              "foo=bar; domain=example.com");
+
 
     c->path = apr_pstrdup(p, "/quux");
-    CuAssertStrEquals(tc, "foo=bar; path=/quux; domain=example.com",
-                      apreq_cookie_as_string(c,p));
+    AT_str_eq(apreq_cookie_as_string(c,p),
+              "foo=bar; path=/quux; domain=example.com");
+    one_year_expiration = apr_pstrcat(p,
+                      "foo=bar; path=/quux; domain=example.com; expires=", 
+                      apreq_expires(p,"+1y",APREQ_EXPIRES_NSCOOKIE), NULL);
+                     
     apreq_cookie_expires(c, "+1y");
-    CuAssertStrEquals(tc,apr_pstrcat(p,
-                         "foo=bar; path=/quux; domain=example.com; expires=", 
-                         apreq_expires(p,"+1y",APREQ_EXPIRES_NSCOOKIE), NULL), 
-                      apreq_cookie_as_string(c,p));
+    AT_str_eq(apreq_cookie_as_string(c,p), one_year_expiration);
 }
+dTEST(netscape_cookie, 6);
 
 
-static void rfc_cookie(CuTest *tc)
+static void rfc_cookie(dAT)
 {
     apreq_cookie_t *c = apreq_make_cookie(p,"rfc",3,"out",3);
-    long expires; 
+    char *three_month_expiration;
 
-    CuAssertStrEquals(tc,"out",apreq_cookie_value(c));
+    AT_str_eq(apreq_cookie_value(c), "out");
     c->version = APREQ_COOKIE_VERSION_RFC;
 
-    CuAssertStrEquals(tc,"rfc=out; Version=1", apreq_cookie_as_string(c,p));
+    AT_str_eq(apreq_cookie_as_string(c,p), "rfc=out; Version=1");
+
     c->domain = apr_pstrdup(p, "example.com");
-    CuAssertStrEquals(tc,"rfc=out; Version=1; domain=\"example.com\"", 
-                      apreq_cookie_as_string(c,p));
+    AT_str_eq(apreq_cookie_as_string(c,p),
+              "rfc=out; Version=1; domain=\"example.com\"");
 
     c->path = apr_pstrdup(p, "/quux");
-    CuAssertStrEquals(tc, 
-              "rfc=out; Version=1; path=\"/quux\"; domain=\"example.com\"",
-                      apreq_cookie_as_string(c,p));
+    AT_str_eq(apreq_cookie_as_string(c,p),
+              "rfc=out; Version=1; path=\"/quux\"; domain=\"example.com\"");
 
     apreq_cookie_expires(c, "+3m");
-    expires = apreq_atoi64t("+3m");
-    CuAssertStrEquals(tc,apr_psprintf(p,
-         "rfc=out; Version=1; path=\"/quux\"; domain=\"example.com\"; max-age=%ld",
-               expires), apreq_cookie_as_string(c,p));
+    three_month_expiration = apr_psprintf(p,
+        "rfc=out; Version=1; path=\"/quux\"; domain=\"example.com\"; max-age=%ld",
+         apreq_atoi64t("+3m"));
+    AT_str_eq(apreq_cookie_as_string(c,p), three_month_expiration);
 
 }
+dTEST(rfc_cookie, 5);
 
-static void ua_version(CuTest *tc)
-{
-    apreq_cookie_version_t v;
-
-    v = apreq_ua_cookie_version(NULL);
-    CuAssertIntEquals(tc, APREQ_COOKIE_VERSION_NETSCAPE, v);
-    v = apreq_ua_cookie_version("$Version=\"1\"");
-    CuAssertIntEquals(tc, APREQ_COOKIE_VERSION_RFC, v);
 
+static void ua_version(dAT)
+{
+    AT_int_eq(apreq_ua_cookie_version(NULL), APREQ_COOKIE_VERSION_NETSCAPE);
+    AT_int_eq(apreq_ua_cookie_version("$Version=\"1\""), APREQ_COOKIE_VERSION_RFC);
 }
+dTEST(ua_version, 2);
 
-CuSuite *testcookie(void)
+
+int main(int argc, char *argv[])
 {
-    CuSuite *suite = CuSuiteNew("Cookie");
+    int i, plan = 0;
+    extern const apreq_env_t test_module;
+    dAT;
+    at_test_t cookie_list [] = {
+        test_jar_make,
+        test_jar_get,
+        test_netscape_cookie,
+        test_rfc_cookie,
+        test_ua_version,
+    };
 
-    SUITE_ADD_TEST(suite, jar_make);
-    SUITE_ADD_TEST(suite, jar_table_get);
-    SUITE_ADD_TEST(suite, netscape_cookie);
-    SUITE_ADD_TEST(suite, rfc_cookie);
-    SUITE_ADD_TEST(suite, ua_version);
+    apr_initialize();
+    atexit(apr_terminate);
+    apreq_env_module(&test_module);
 
-    return suite;
-}
+    apr_pool_create(&p, NULL);
+
+    AT = at_create(p, 0, at_report_stdout_make(p)); 
+
+    for (i = 0; i < sizeof(cookie_list) / sizeof(at_test_t);  ++i)
+        plan += cookie_list[i].plan;
 
+    AT_begin(plan);
+
+    for (i = 0; i < sizeof(cookie_list) / sizeof(at_test_t);  ++i)
+        AT_run(&cookie_list[i]);
+
+    AT_end();
+
+    return 0;
+}

Modified: httpd/apreq/trunk/t/params.c
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/params.c?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/t/params.c (original)
+++ httpd/apreq/trunk/t/params.c Sat Feb 12 15:04:35 2005
@@ -15,55 +15,51 @@
 */
 
 #include "apreq_env.h"
-#include "test_apreq.h"
 #include "apreq.h"
 #include "apreq_params.h"
 #include "apr_strings.h"
+#include "at.h"
 
 static apreq_request_t *r = NULL;
+extern apr_pool_t *p;
 
-static void request_make(CuTest *tc)
+static void request_make(dAT)
 {
     r = apreq_request(NULL,"a=1;quux=foo+bar&a=2&plus=%2B;uplus=%U002b;okie=dokie;novalue1;novalue2=");
-    CuAssertPtrNotNull(tc, r);
-    CuAssertIntEquals(tc,8, apr_table_elts(r->args)->nelts);
+    AT_not_null(r);
+    AT_int_eq(apr_table_elts(r->args)->nelts, 8);
 }
 
-static void request_args_get(CuTest *tc)
+static void request_args_get(dAT)
 {
     const char *val;
     apreq_value_t *v;
 
-    val = apr_table_get(r->args,"a");
-    CuAssertStrEquals(tc,"1",val);
+    AT_str_eq(apr_table_get(r->args,"a"), "1");
+
     val = apr_table_get(r->args,"quux");
-    CuAssertStrEquals(tc,"foo bar",val);
+    AT_str_eq(val, "foo bar");
     v = apreq_strtoval(val);
-    CuAssertIntEquals(tc, 7, v->size);
-    val = apr_table_get(r->args,"plus");
-    CuAssertStrEquals(tc,"+",val);
-    val = apr_table_get(r->args,"uplus");
-    CuAssertStrEquals(tc,"+",val);
-    val = apr_table_get(r->args,"okie");
-    CuAssertStrEquals(tc,"dokie",val);
-    val = apr_table_get(r->args,"novalue1");
-    CuAssertStrEquals(tc,"",val);
-    val = apr_table_get(r->args,"novalue2");
-    CuAssertStrEquals(tc,"",val);
+    AT_int_eq(v->size, 7);
 
+    AT_str_eq(apr_table_get(r->args,"plus"), "+");
+    AT_str_eq(apr_table_get(r->args,"uplus"), "+");
+    AT_str_eq(apr_table_get(r->args,"okie"), "dokie");
+    AT_str_eq(apr_table_get(r->args,"novalue1"), "");
+    AT_str_eq(apr_table_get(r->args,"novalue2"),"");
 }
 
-static void params_as(CuTest *tc)
+static void params_as(dAT)
 {
     const char *val;
     apr_array_header_t *arr;
     arr = apreq_params_as_array(p,r,"a");
-    CuAssertIntEquals(tc,2,arr->nelts);
+    AT_int_eq(arr->nelts, 2);
     val = apreq_params_as_string(p,r,"a",APREQ_JOIN_AS_IS);
-    CuAssertStrEquals(tc,"1, 2", val);
+    AT_str_eq(val, "1, 2");
 }
 
-static void string_decoding_in_place(CuTest *tc)
+static void string_decoding_in_place(dAT)
 {
     char *s1 = apr_palloc(p,4096);
     char *s2 = apr_palloc(p,4096);
@@ -72,24 +68,24 @@
     strcpy(s1, "bend it like beckham");
     strcpy(s2, "dandy %3Edons");
 
-    CuAssertStrEquals(tc,"bend it like beckham",s1);
+    AT_str_eq(s1,"bend it like beckham");
     apreq_unescape(s1);
-    CuAssertStrEquals(tc,"bend it like beckham",s1);
+    AT_str_eq(s1, "bend it like beckham");
     s3 = apreq_escape(p, s1, 20);
-    CuAssertStrEquals(tc,"bend+it+like+beckham",s3);
+    AT_str_eq(s3, "bend+it+like+beckham");
     apreq_unescape(s3);
-    CuAssertStrEquals(tc,"bend it like beckham",s3);
+    AT_str_eq(s3,"bend it like beckham");
 
-    CuAssertStrEquals(tc,"dandy %3Edons",s2);
+    AT_str_eq(s2,"dandy %3Edons");
     apreq_unescape(s2);
-    CuAssertStrEquals(tc,"dandy >dons",s2);
+    AT_str_eq(s2,"dandy >dons");
     s3 = apreq_escape(p, s2, 11);
-    CuAssertStrEquals(tc,"dandy+%3edons",s3);
+    AT_str_eq(s3,"dandy+%3edons");
     apreq_unescape(s3);
-    CuAssertStrEquals(tc,"dandy >dons",s3); 
+    AT_str_eq(s3,"dandy >dons"); 
 }
 
-static void header_attributes(CuTest *tc)
+static void header_attributes(dAT)
 {
     const char *hdr = "text/plain; boundary=\"-foo-\", charset=ISO-8859-1";
     const char *val;
@@ -97,38 +93,37 @@
     apr_status_t s;
 
     s = apreq_header_attribute(hdr, "none", 4, &val, &vlen);
-    CuAssertIntEquals(tc, APR_NOTFOUND, s);
+    AT_int_eq(s, APR_NOTFOUND);
 
     s = apreq_header_attribute(hdr, "set", 3, &val, &vlen);
-    CuAssertIntEquals(tc, APR_NOTFOUND, s);
+    AT_int_eq(s, APR_NOTFOUND);
 
     s = apreq_header_attribute(hdr, "boundary", 8, &val, &vlen);
-    CuAssertIntEquals(tc, APR_SUCCESS, s);
-    CuAssertIntEquals(tc, 5, vlen);
-    CuAssertStrNEquals(tc, "-foo-", val, 5);
+    AT_int_eq(s, APR_SUCCESS);
+    AT_int_eq(vlen, 5);
+    AT_mem_eq(val, "-foo-", 5);
 
     s = apreq_header_attribute(hdr, "charset", 7, &val, &vlen);
-    CuAssertIntEquals(tc, APR_SUCCESS, s);
-    CuAssertIntEquals(tc, 10, vlen);
-    CuAssertStrNEquals(tc, "ISO-8859-1", val, 10);
+    AT_int_eq(s, APR_SUCCESS);
+    AT_int_eq(vlen, 10);
+    AT_mem_eq(val, "ISO-8859-1", 10);
 
     hdr = "max-age=20; no-quote=\"...";
 
     s = apreq_header_attribute(hdr, "max-age", 7, &val, &vlen);
-    CuAssertIntEquals(tc, APR_SUCCESS, s);
-    CuAssertIntEquals(tc, 2, vlen);
-    CuAssertStrNEquals(tc, "20", val, 2);
+    AT_int_eq(s, APR_SUCCESS);
+    AT_int_eq(vlen, 2);
+    AT_mem_eq(val, "20", 2);
 
     s = apreq_header_attribute(hdr, "age", 3, &val, &vlen);
-    CuAssertIntEquals(tc, APR_EGENERAL, s);
+    AT_int_eq(s, APR_EGENERAL);
 
     s = apreq_header_attribute(hdr, "no-quote", 8, &val, &vlen);
-    CuAssertIntEquals(tc, APR_EGENERAL, s);
-
+    AT_int_eq(s, APR_EGENERAL);
 
 }
 
-static void make_values(CuTest *tc)
+static void make_values(dAT)
 {
     apreq_value_t *v1, *v2;
     apr_size_t len = 4;
@@ -138,41 +133,41 @@
     strcpy(val, "bar");
  
     v1 = apreq_make_value(p, name, len, val, len);
-    CuAssertStrEquals(tc, name, v1->name);
-    CuAssertIntEquals(tc, len, v1->size);
-    CuAssertStrEquals(tc, val, v1->data);
+    AT_str_eq(v1->name, name);
+    AT_int_eq(v1->size, len);
+    AT_str_eq(v1->data, val);
 
     v2 = apreq_copy_value(p, v1);
-    CuAssertStrEquals(tc, name, v2->name);
-    CuAssertIntEquals(tc, len, v2->size);
-    CuAssertStrEquals(tc, val, v2->data);
+    AT_str_eq(v2->name, name);
+    AT_int_eq(v2->size, len);
+    AT_str_eq(v2->data, val);
 }
 
-static void make_param(CuTest *tc)
+static void make_param(dAT)
 {
-    apreq_param_t *param, *result;
+    apreq_param_t *param, *decode;
     apr_size_t nlen = 3, vlen = 11;
     char *name = apr_palloc(p,nlen+1);
     char *val = apr_palloc(p,vlen+1);
-    char *encode = apr_palloc(p,vlen+nlen+1);
+    char *encode;
     strcpy(name, "foo");
     strcpy(val, "bar > alpha");
  
     param = apreq_make_param(p, name, nlen, val, vlen);
-    CuAssertStrEquals(tc, name, param->v.name);
-    CuAssertIntEquals(tc, vlen, param->v.size);
-    CuAssertStrEquals(tc, val, param->v.data);
+    AT_str_eq(param->v.name, name);
+    AT_int_eq(param->v.size, vlen);
+    AT_str_eq(param->v.data, val);
 
     encode = apreq_encode_param(p, param);
-    CuAssertStrEquals(tc, "foo=bar+%3e+alpha", encode);
+    AT_str_eq(encode, "foo=bar+%3e+alpha");
 
-    result = apreq_decode_param(p, encode, nlen, vlen+2);
-    CuAssertStrEquals(tc, name, result->v.name);
-    CuAssertIntEquals(tc, vlen, result->v.size);
-    CuAssertStrEquals(tc, val, result->v.data);
+    decode = apreq_decode_param(p, encode, nlen, vlen+2);
+    AT_str_eq(decode->v.name, name);
+    AT_int_eq(decode->v.size, vlen);
+    AT_str_eq(decode->v.data, val);
 }
 
-static void quote_strings(CuTest *tc)
+static void quote_strings(dAT)
 {
     apr_size_t exp_len, res_len, res_quote_len;
     char *res = apr_palloc(p,24);
@@ -187,20 +182,20 @@
 
     for (i=0; i<4; i++) {
         res_len = apreq_quote(res, arr[i], arr_len[i]);
-        CuAssertIntEquals(tc, arr_quote_len[i], res_len);
-        CuAssertStrNEquals(tc, arr_quote[i], res, res_len);
+        AT_int_eq(res_len, arr_quote_len[i]);
+        AT_mem_eq(res, arr_quote[i], res_len);
         res_quote_len = apreq_quote_once(res_quote, res, res_len);
-        CuAssertIntEquals(tc, res_len, res_quote_len);
-        CuAssertStrNEquals(tc, res, res_quote, res_len);
+        AT_int_eq(res_quote_len, res_len);
+        AT_mem_eq(res_quote, res, res_len);
         res_len = apreq_quote_once(res, arr[i], arr_len[i]);
         exp_len = (i == 3) ? arr_len[i] : arr_quote_len[i];
         exp = (i == 3) ? arr[i] : arr_quote[i];
-        CuAssertIntEquals(tc, exp_len, res_len);
-        CuAssertStrNEquals(tc, exp, res, exp_len);
+        AT_int_eq(res_len, exp_len);
+        AT_mem_eq(res, exp, exp_len);
     }
 }
 
-static void test_memmem(CuTest *tc)
+static void test_memmem(dAT)
 {
     char *hay = apr_palloc(p,29);
     char *partial, *full;
@@ -208,35 +203,60 @@
     strcpy(hay, "The fear of fear is fearful.");
 
     partial = apreq_memmem(hay, hlen, "fear of fly", 11, APREQ_MATCH_PARTIAL);
-    if (partial == NULL) CuAssertTrue(tc, 1);
+    AT_is_null(partial);
     partial = apreq_memmem(hay, hlen, "fear ", 5, APREQ_MATCH_PARTIAL);
-    CuAssertStrEquals(tc, "fear of fear is fearful.", partial);
+    AT_str_eq(partial, "fear of fear is fearful.");
     partial = apreq_memmem(hay, hlen, "fear is", 7, APREQ_MATCH_PARTIAL);
-    CuAssertStrEquals(tc, "fear is fearful.", partial);
+    AT_str_eq(partial, "fear is fearful.");
     partial = apreq_memmem(hay, hlen, hay, hlen, APREQ_MATCH_PARTIAL);
-    CuAssertStrEquals(tc, hay, partial);
+    AT_str_eq(partial, hay);
+
     full = apreq_memmem(hay, hlen, "fear is", 7, APREQ_MATCH_FULL);
-    if (full == NULL) CuAssertTrue(tc, 1);
+    AT_not_null(full);
     partial = apreq_memmem(hay, hlen, "fear of fly", 11, APREQ_MATCH_FULL);
-    if (partial == NULL) CuAssertTrue(tc, 1);
+    AT_is_null(partial);
     full = apreq_memmem(hay, hlen, hay, hlen, APREQ_MATCH_FULL);
-    CuAssertStrEquals(tc, hay, full);
+    AT_str_eq(full, hay);
 }
 
-CuSuite *testparam(void)
+#define dT(func, plan) {#func, func, plan}
+
+int main(int argc, char *argv[])
 {
-    CuSuite *suite = CuSuiteNew("Param");
+    extern const apreq_env_t test_module;
+    extern apr_pool_t *p;
+    int i, plan = 0;
+    dAT;
+    at_test_t test_list [] = {
+        dT(request_make, 2),
+        dT(request_args_get, 8),
+        dT(params_as, 2),
+        dT(string_decoding_in_place, 8),
+        dT(header_attributes, 13),
+        dT(make_values, 6),
+        dT(make_param, 7),
+        dT(quote_strings, 24),
+        dT(test_memmem, 7),
+    };
+
+    apr_initialize();
+    atexit(apr_terminate);
+    apreq_env_module(&test_module);
+
+    apr_pool_create(&p, NULL);
+
+    AT = at_create(p, 0, at_report_stdout_make(p)); 
+    AT_trace_on();
+    for (i = 0; i < sizeof(test_list) / sizeof(at_test_t);  ++i)
+        plan += test_list[i].plan;
+
+    AT_begin(plan);
+
+    for (i = 0; i < sizeof(test_list) / sizeof(at_test_t);  ++i)
+        AT_run(&test_list[i]);
 
-    SUITE_ADD_TEST(suite, request_make);
-    SUITE_ADD_TEST(suite, request_args_get);
-    SUITE_ADD_TEST(suite, params_as);
-    SUITE_ADD_TEST(suite, string_decoding_in_place);
-    SUITE_ADD_TEST(suite, header_attributes);
-    SUITE_ADD_TEST(suite, make_values);
-    SUITE_ADD_TEST(suite, quote_strings);
-    SUITE_ADD_TEST(suite, make_param);
-    SUITE_ADD_TEST(suite, test_memmem);
+    AT_end();
 
-    return suite;
+    return 0;
 }
 

Modified: httpd/apreq/trunk/t/parsers.c
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/parsers.c?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/t/parsers.c (original)
+++ httpd/apreq/trunk/t/parsers.c Sat Feb 12 15:04:35 2005
@@ -15,11 +15,11 @@
 */
 
 #include "apreq_env.h"
-#include "test_apreq.h"
 #include "apreq.h"
 #include "apreq_params.h"
 #include "apr_strings.h"
 #include "apr_xml.h"
+#include "at.h"
 
 #define CRLF "\015\012"
 
@@ -101,47 +101,46 @@
 
 extern apr_bucket_brigade *bb;
 extern apr_table_t *table;
+extern apr_pool_t *p;
 
-static void locate_default_parsers(CuTest *tc)
+static void locate_default_parsers(dAT)
 {
     apreq_request_t *req;
     apreq_parser_t *parser;
 
     req = apreq_request("application/x-www-form-urlencoded", "");
-    CuAssertPtrNotNull(tc, req);
-    CuAssertStrEquals(tc, APREQ_URL_ENCTYPE, apreq_enctype(req->env));
+    AT_not_null(req);
+    AT_str_eq(apreq_enctype(req->env), APREQ_URL_ENCTYPE);
     parser = apreq_parser(req->env, NULL);
-    CuAssertPtrNotNull(tc, parser);
-    CuAssertStrEquals(tc, APREQ_URL_ENCTYPE, parser->enctype);
+    AT_not_null(parser);
+    AT_str_eq(parser->enctype, APREQ_URL_ENCTYPE);
 
     req = apreq_request(APREQ_MFD_ENCTYPE
                         "; charset=\"iso-8859-1\"; boundary=\"AaB03x\"" ,"");
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
     parser = apreq_parser(req->env, NULL);
-    CuAssertPtrNotNull(tc, parser);
-    CuAssertStrNEquals(tc, APREQ_MFD_ENCTYPE, parser->enctype, 
-                       strlen(APREQ_MFD_ENCTYPE));
+    AT_not_null(parser);
+    AT_mem_eq(APREQ_MFD_ENCTYPE, parser->enctype, sizeof(APREQ_MFD_ENCTYPE)-1);
 
     req = apreq_request("multipart/related; boundary=f93dcbA3; "
         "type=application/xml; start=\"<980119.X53GGT@example.com>\"","");
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
     parser = apreq_parser(req->env, NULL);
-    CuAssertPtrNotNull(tc, parser);
-    CuAssertStrNEquals(tc, "multipart/related", parser->enctype, 
-                       strlen("multipart/related"));
+    AT_not_null(parser);
+    AT_mem_eq("multipart/related", parser->enctype, sizeof("multipart/related")-1);
 }
 
 
-static void parse_urlencoded(CuTest *tc)
+static void parse_urlencoded(dAT)
 {
     const char *val;
     apreq_request_t *req = apreq_request(APREQ_URL_ENCTYPE,"");
     apr_status_t rv;
     const char *enctype;
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
 
     enctype = apreq_enctype(req->env);
-    CuAssertStrEquals(tc, APREQ_URL_ENCTYPE, enctype);
+    AT_str_eq(APREQ_URL_ENCTYPE, enctype);
 
     bb = apr_brigade_create(p, apr_bucket_alloc_create(p));
 
@@ -150,7 +149,7 @@
                                    bb->bucket_alloc));
 
     rv = apreq_parse_request(req,bb);
-    CuAssertIntEquals(tc, APR_INCOMPLETE, rv);
+    AT_int_eq(APR_INCOMPLETE, rv);
 
     APR_BRIGADE_INSERT_HEAD(bb,
         apr_bucket_immortal_create("blast",5, 
@@ -160,19 +159,19 @@
 
     rv = apreq_parse_request(req,bb);
 
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    AT_int_eq(APR_SUCCESS, rv);
 
     val = apr_table_get(req->body,"alpha");
 
-    CuAssertStrEquals(tc, "one", val);
+    AT_str_eq("one", val);
     val = apr_table_get(req->body,"beta");
-    CuAssertStrEquals(tc, "two", val);
+    AT_str_eq("two", val);
     val = apr_table_get(req->body,"omega");
-    CuAssertStrEquals(tc, "last+last", val);
+    AT_str_eq("last+last", val);
 
 }
 
-static void parse_multipart(CuTest *tc)
+static void parse_multipart(dAT)
 {
     apr_status_t rv;
     apr_size_t i, j;
@@ -184,15 +183,23 @@
         apreq_request_t *req = apreq_request(APREQ_MFD_ENCTYPE
                          "; charset=\"iso-8859-1\"; boundary=\"AaB03x\"" ,"");
 
-        CuAssertPtrNotNull(tc, req);
-        CuAssertStrEquals(tc, req->env, apreq_env_content_type(req->env));
+        AT_not_null(req);
+        AT_str_eq(req->env, apreq_env_content_type(req->env));
 
         enctype = apreq_enctype(req->env);
-        CuAssertStrEquals(tc, APREQ_MFD_ENCTYPE, enctype);
+        AT_str_eq(APREQ_MFD_ENCTYPE, enctype);
 
         ba = apr_bucket_alloc_create(p);
         bb = apr_brigade_create(p, ba);
 
+        /* AT_localize checks the inner loop tests itself
+         * (and interprets any such failures as being fatal),
+         * because doing IO to Test::Harness is just too slow
+         * when this many (~1M) tests are involved.
+         */
+
+        AT_localize(p);
+
         for (i = 0; i <= strlen(form_data); ++i) {
             const char *val;
             apr_size_t len;
@@ -205,7 +212,6 @@
             apr_bucket_brigade *tail;
             APR_BRIGADE_INSERT_HEAD(bb, e);
             APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));
-
             /* Split e into three buckets */
             apr_bucket_split(e, j);
             f = APR_BUCKET_NEXT(e);
@@ -219,28 +225,28 @@
             req->parser = NULL;
             req->body_status = APR_EINIT;
             rv = apreq_parse_request(req,bb);
-            CuAssertIntEquals(tc, (j < strlen(form_data)) ? APR_INCOMPLETE : APR_SUCCESS, rv);
+            AT_int_eq(rv, (j < strlen(form_data)) ? APR_INCOMPLETE : APR_SUCCESS);
             rv = apreq_parse_request(req, tail);
-            CuAssertIntEquals(tc, APR_SUCCESS, rv);
-            CuAssertPtrNotNull(tc, req->body);
-            CuAssertIntEquals(tc, 2, apr_table_elts(req->body)->nelts);
+            AT_int_eq(rv, APR_SUCCESS);
+            AT_not_null(req->body);
+            AT_int_eq(apr_table_elts(req->body)->nelts, 2);
 
             val = apr_table_get(req->body,"field1");
 
-            CuAssertStrEquals(tc, "Joe owes =80100.", val);
+            AT_str_eq("Joe owes =80100.", val);
             t = apreq_value_to_param(apreq_strtoval(val))->info;
             val = apr_table_get(t, "content-transfer-encoding");
-            CuAssertStrEquals(tc,"quoted-printable", val);
+            AT_str_eq("quoted-printable", val);
 
             val = apr_table_get(req->body, "pics");
-            CuAssertStrEquals(tc, "file1.txt", val);
+            AT_str_eq("file1.txt", val);
             t = apreq_value_to_param(apreq_strtoval(val))->info;
             bb = apreq_value_to_param(apreq_strtoval(val))->bb;
             apr_brigade_pflatten(bb, (char **)&val, &len, p);
-            CuAssertIntEquals(tc,strlen("... contents of file1.txt ..." CRLF), len);
-            CuAssertStrNEquals(tc,"... contents of file1.txt ..." CRLF, val, len);
+            AT_int_eq(strlen("... contents of file1.txt ..." CRLF), len);
+            AT_mem_eq("... contents of file1.txt ..." CRLF, val, len);
             val = apr_table_get(t, "content-type");
-            CuAssertStrEquals(tc, "text/plain", val);
+            AT_str_eq("text/plain", val);
             apr_brigade_cleanup(bb);
         }
         apr_bucket_alloc_destroy(ba);
@@ -248,7 +254,7 @@
     }
 }
 
-static void parse_disable_uploads(CuTest *tc)
+static void parse_disable_uploads(dAT)
 {
     const char *val;
     apr_table_t *t;
@@ -261,8 +267,8 @@
                                                    strlen(form_data),
                                                    bb->bucket_alloc);
 
-    CuAssertPtrNotNull(tc, req);
-    CuAssertStrEquals(tc, req->env, apreq_env_content_type(req->env));
+    AT_not_null(req);
+    AT_str_eq(req->env, apreq_env_content_type(req->env));
 
     APR_BRIGADE_INSERT_HEAD(bb, e);
     APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));
@@ -272,21 +278,21 @@
                                  apreq_hook_disable_uploads, NULL, NULL));
 
     rv = apreq_parse_request(req,bb);
-    CuAssertIntEquals(tc, APR_EGENERAL, rv);
-    CuAssertPtrNotNull(tc, req->body);
-    CuAssertIntEquals(tc, 1, apr_table_elts(req->body)->nelts);
+    AT_int_eq(APR_EGENERAL, rv);
+    AT_not_null(req->body);
+    AT_int_eq(apr_table_elts(req->body)->nelts, 1);
 
     val = apr_table_get(req->body,"field1");
-    CuAssertStrEquals(tc, "Joe owes =80100.", val);
+    AT_str_eq("Joe owes =80100.", val);
     t = apreq_value_to_param(apreq_strtoval(val))->info;
     val = apr_table_get(t, "content-transfer-encoding");
-    CuAssertStrEquals(tc,"quoted-printable", val);
+    AT_str_eq("quoted-printable", val);
 
     val = apr_table_get(req->body, "pics");
-    CuAssertPtrEquals(tc, NULL, val);
+    AT_is_null(val);
 }
 
-static void parse_generic(CuTest *tc)
+static void parse_generic(dAT)
 {
     const char *val;
     apr_size_t vlen;
@@ -299,7 +305,7 @@
                                                    strlen(xml_data),
                                                    bb->bucket_alloc);
 
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
     APR_BRIGADE_INSERT_HEAD(bb, e);
     APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));
 
@@ -307,16 +313,16 @@
     req->parser = apreq_make_parser(p, APREQ_XML_ENCTYPE, 
                                     apreq_parse_generic, NULL, NULL);
     rv = apreq_parse_request(req,bb);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    AT_int_eq(APR_SUCCESS, rv);
     dummy = *(apreq_param_t **)req->parser->ctx;
-    CuAssertPtrNotNull(tc, dummy);
+    AT_not_null(dummy);
     apr_brigade_pflatten(dummy->bb, (char **)&val, &vlen, p);
 
-    CuAssertIntEquals(tc, strlen(xml_data), vlen);
-    CuAssertStrNEquals(tc, xml_data, val, vlen);
+    AT_int_eq(strlen(xml_data), vlen);
+    AT_mem_eq(xml_data, val, vlen);
 }
 
-static void hook_discard(CuTest *tc)
+static void hook_discard(dAT)
 {
     apr_status_t rv;
     apreq_param_t *dummy;
@@ -327,7 +333,7 @@
                                                    strlen(xml_data),
                                                    bb->bucket_alloc);
 
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
     APR_BRIGADE_INSERT_HEAD(bb, e);
     APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));
 
@@ -337,16 +343,16 @@
                                     apreq_make_hook(p, apreq_hook_discard_brigade,
                                                     NULL,NULL), NULL);
     rv = apreq_parse_request(req,bb);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    AT_int_eq(rv, APR_SUCCESS);
     dummy = *(apreq_param_t **)req->parser->ctx;
-    CuAssertPtrNotNull(tc, dummy);
-    CuAssertPtrNotNull(tc, dummy->bb);
-    CuAssertTrue(tc, APR_BRIGADE_EMPTY(dummy->bb));
+    AT_not_null(dummy);
+    AT_not_null(dummy->bb);
+    AT_ok(APR_BRIGADE_EMPTY(dummy->bb), "nothing in dummy brigade");
 
 }
 
 
-static void parse_related(CuTest *tc)
+static void parse_related(dAT)
 {
     char ct[] = "multipart/related; boundary=f93dcbA3; "
         "type=application/xml; start=\"<980119.X53GGT@example.com>\"";
@@ -366,7 +372,7 @@
                                                    strlen(rel_data),
                                                    bb->bucket_alloc);
 
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
     APR_BRIGADE_INSERT_HEAD(bb, e);
     APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));
     xml_hook = apreq_make_hook(p, apreq_hook_apr_xml_parser, NULL, NULL);
@@ -375,38 +381,38 @@
     req->parser = apreq_make_parser(p, ct, 
                                     apreq_parse_multipart, xml_hook, NULL);
     rv = apreq_parse_request(req,bb);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
-    CuAssertPtrNotNull(tc, req->body);
+    AT_int_eq(rv, APR_SUCCESS);
+    AT_not_null(req->body);
 
     param = apreq_param(req, "<980119.X53GGT@example.com>");
-    CuAssertPtrNotNull(tc, param);
-    CuAssertPtrNotNull(tc, param->info);
+    AT_not_null(param);
+    AT_not_null(param->info);
     val = apr_table_get(param->info, "Content-Length");
-    CuAssertStrEquals(tc, "400", val);
-    CuAssertPtrNotNull(tc, param->bb);
+    AT_str_eq(val, "400");
+    AT_not_null(param->bb);
     apr_brigade_pflatten(param->bb, (char **)&val, &vlen, p);
-    CuAssertIntEquals(tc, 400, vlen);
-    CuAssertStrNEquals(tc,rel_data + 122, val, 400);
+    AT_int_eq(vlen, 400);
+    AT_mem_eq(val, rel_data + 122, 400);
 
     doc = *(apr_xml_doc **)xml_hook->ctx;
     apr_xml_to_text(p, doc->root, APR_XML_X2T_FULL,
                     doc->namespaces, &ns_map, &val, &vlen);
-    CuAssertIntEquals(tc, 400 - 22, vlen);
-    CuAssertStrNEquals(tc, rel_data + 122 + 23, val, 400 - 23);
+    AT_int_eq(vlen, 400 - 22);
+    AT_mem_eq(val, rel_data + 122 + 23, 400 - 23);
 
     param = apreq_param(req, "<980119.X25MNC@example.com>");
-    CuAssertPtrNotNull(tc, param);
-    CuAssertPtrNotNull(tc, param->bb);
+    AT_not_null(param);
+    AT_not_null(param->bb);
     apr_brigade_pflatten(param->bb, (char **)&val, &vlen, p);
-    CuAssertIntEquals(tc, dlen, vlen);
-    CuAssertStrNEquals(tc, data, val, vlen);
+    AT_int_eq(dlen, vlen);
+    AT_mem_eq(data, val, vlen);
 
     param = apreq_param(req, "<980119.X17AXM@example.com>");
-    CuAssertPtrNotNull(tc, param);
-    CuAssertPtrNotNull(tc, param->bb);
+    AT_not_null(param);
+    AT_not_null(param->bb);
     apr_brigade_pflatten(param->bb, (char **)&val, &vlen, p);
-    CuAssertIntEquals(tc, dlen, vlen);
-    CuAssertStrNEquals(tc, data, val, vlen);
+    AT_int_eq(dlen, vlen);
+    AT_mem_eq(data, val, vlen);
 }
 
 typedef struct {
@@ -415,7 +421,7 @@
 } array_elt;
 
 
-static void parse_mixed(CuTest *tc)
+static void parse_mixed(dAT)
 {
     const char *val;
     apr_size_t vlen;
@@ -431,56 +437,85 @@
                                                    strlen(mix_data),
                                                    bb->bucket_alloc);
 
-    CuAssertPtrNotNull(tc, req);
+    AT_not_null(req);
     APR_BRIGADE_INSERT_HEAD(bb, e);
     APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));
 
     rv = apreq_parse_request(req,bb);
-    CuAssertIntEquals(tc, APR_SUCCESS, rv);
+    AT_int_eq(APR_SUCCESS, rv);
 
     param = apreq_param(req, "submit-name");
-    CuAssertPtrNotNull(tc, param);
-    CuAssertStrEquals(tc, "Larry", param->v.data);
+    AT_not_null(param);
+    AT_str_eq("Larry", param->v.data);
 
     val = apr_table_get(req->body,"field1");
-    CuAssertStrEquals(tc, "Joe owes =80100.", val);
+    AT_str_eq("Joe owes =80100.", val);
 
     param = apreq_param(req, "files");
-    CuAssertPtrNotNull(tc, param);
-    CuAssertStrEquals(tc, "file1.txt", param->v.data);
+    AT_not_null(param);
+    AT_str_eq("file1.txt", param->v.data);
 
-    CuAssertPtrNotNull(tc, param->bb);
+    AT_not_null(param->bb);
     apr_brigade_pflatten(param->bb, (char **)&val, &vlen, p);
-    CuAssertIntEquals(tc, strlen("... contents of file1.txt ..."), vlen);
-    CuAssertStrNEquals(tc, "... contents of file1.txt ...", val, vlen);
+    AT_int_eq(strlen("... contents of file1.txt ..."), vlen);
+    AT_mem_eq("... contents of file1.txt ...", val, vlen);
 
     arr = apr_table_elts(req->body);
-    CuAssertIntEquals(tc, 4, arr->nelts);
+    AT_int_eq(4, arr->nelts);
 
     elt = (array_elt *)&arr->elts[2 * arr->elt_size];
-    CuAssertStrEquals(tc, "files", elt->key);
-    CuAssertStrEquals(tc, "file2.gif", elt->val);
+    AT_str_eq("files", elt->key);
+    AT_str_eq("file2.gif", elt->val);
 
     param = apreq_value_to_param(apreq_strtoval(elt->val));
-    CuAssertPtrNotNull(tc, param->bb);
+    AT_not_null(param->bb);
     apr_brigade_pflatten(param->bb, (char **)&val, &vlen, p);
-    CuAssertIntEquals(tc, strlen("...contents of file2.gif..."), vlen);
-    CuAssertStrNEquals(tc, "...contents of file2.gif...", val, vlen);
+    AT_int_eq(strlen("...contents of file2.gif..."), vlen);
+    AT_mem_eq("...contents of file2.gif...", val, vlen);
 
 }
 
 
-CuSuite *testparser(void)
+#define dT(func, plan) {#func, func, plan}
+
+int main(int argc, char *argv[])
 {
-    CuSuite *suite = CuSuiteNew("Parsers");
-    SUITE_ADD_TEST(suite, locate_default_parsers);
-    SUITE_ADD_TEST(suite, parse_urlencoded);
-    SUITE_ADD_TEST(suite, parse_multipart);
-    SUITE_ADD_TEST(suite, parse_disable_uploads);
-    SUITE_ADD_TEST(suite, parse_generic);
-    SUITE_ADD_TEST(suite, parse_related);
-    SUITE_ADD_TEST(suite, parse_mixed);
-    SUITE_ADD_TEST(suite, hook_discard);
-    return suite;
+    extern const apreq_env_t test_module;
+    extern apr_pool_t *p;
+    apr_pool_t *test_pool;
+    int i, plan = 0;
+    dAT;
+    at_test_t test_list [] = {        
+        dT(locate_default_parsers, 10),
+        dT(parse_urlencoded, 7),
+        dT(parse_multipart, 4  * sizeof form_data),
+        dT(parse_disable_uploads, 8),
+        dT(parse_generic, 5),
+        dT(hook_discard, 5),
+        dT(parse_related, 19),
+        dT(parse_mixed, 16)
+    };
+
+    apr_initialize();
+    atexit(apr_terminate);
+    apreq_env_module(&test_module);
+
+    apr_pool_create(&p, NULL);
+    apr_pool_create(&test_pool, NULL);
+
+    AT = at_create(test_pool, 0, at_report_stdout_make(test_pool)); 
+//    AT_trace_on();
+    for (i = 0; i < sizeof(test_list) / sizeof(at_test_t);  ++i)
+        plan += test_list[i].plan;
+
+    AT_begin(plan);
+
+    for (i = 0; i < sizeof(test_list) / sizeof(at_test_t);  ++i)
+        AT_run(&test_list[i]);
+
+    AT_end();
+
+    return 0;
 }
+
 

Modified: httpd/apreq/trunk/t/test_apreq.h
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/test_apreq.h?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/t/test_apreq.h (original)
+++ httpd/apreq/trunk/t/test_apreq.h Sat Feb 12 15:04:35 2005
@@ -16,7 +16,7 @@
 
 #ifndef APREQ_TEST_INCLUDES
 #define APREQ_TEST_INCLUDES
-
+#include "at.h"
 #include "CuTest.h"
 #include "apr_pools.h"
 #ifndef apr_table_nelts
@@ -41,5 +41,10 @@
  * for RV and CONTEXT message. */
 void apr_assert_success(CuTest* tc, const char *context, apr_status_t rv);
 
+AT_DECLARE_TEST(jar_make);
+AT_DECLARE_TEST(jar_get);
+AT_DECLARE_TEST(netscape_cookie);
+AT_DECLARE_TEST(rfc_cookie);
+AT_DECLARE_TEST(ua_version);
 
 #endif /* APR_TEST_INCLUDES */

Added: httpd/apreq/trunk/t/test_env.c
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/test_env.c?view=auto&rev=153577
==============================================================================
--- httpd/apreq/trunk/t/test_env.c (added)
+++ httpd/apreq/trunk/t/test_env.c Sat Feb 12 15:04:35 2005
@@ -0,0 +1,141 @@
+/*
+**  Copyright 2003-2004  The Apache Software Foundation
+**
+**  Licensed under the Apache License, Version 2.0 (the "License");
+**  you may not use this file except in compliance with the License.
+**  You may obtain a copy of the License at
+**
+**      http://www.apache.org/licenses/LICENSE-2.0
+**
+**  Unless required by applicable law or agreed to in writing, software
+**  distributed under the License is distributed on an "AS IS" BASIS,
+**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+**  See the License for the specific language governing permissions and
+**  limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "apreq_env.h"
+#include "apr_strings.h"
+
+apr_pool_t *p;
+
+/* rigged environent for unit tests */
+
+#define APREQ_MODULE_NAME "TEST"
+#define APREQ_MODULE_MAGIC_NUMBER 20040324
+
+#define CRLF "\015\012"
+
+apr_bucket_brigade *bb;
+apr_table_t *table;
+
+static apr_pool_t *test_pool(void *env)
+{
+    return p;
+}
+
+static apr_status_t bucket_alloc_cleanup(void *data)
+{
+    apr_bucket_alloc_t *ba = data;
+    apr_bucket_alloc_destroy(ba);
+    return APR_SUCCESS;
+}
+
+static apr_bucket_alloc_t *test_bucket_alloc(void *env)
+{
+    apr_bucket_alloc_t *ba = apr_bucket_alloc_create(p);
+    apr_pool_cleanup_register(p, ba, bucket_alloc_cleanup, NULL);
+    return ba;
+}
+
+static const char *test_header_in(void *env, const char *name)
+{
+    return env;
+}
+
+static apr_status_t test_header_out(void *env, 
+                                    const char *name, 
+                                    char *value)
+{    
+    return printf("%s: %s" CRLF, name, value) > 0 ? APR_SUCCESS : APR_EGENERAL;
+}
+
+static const char *test_query_string(void *env)
+{
+    return env;
+}
+
+static apreq_jar_t *test_jar(void *env, apreq_jar_t *jar)
+{
+    return NULL;
+}
+
+static apreq_request_t *test_request(void *env, apreq_request_t *req)
+{
+    return NULL;
+}
+
+static void test_log(const char *file, int line, int level, 
+                     apr_status_t status, void *env, const char *fmt,
+                     va_list vp)
+{
+    char buf[256];
+    if (level < APREQ_LOG_ERR)
+        fprintf(stderr, "[%s(%d)]%s (%s)\n", file, line, apr_strerror(status,buf,255), apr_pvsprintf(p,fmt,vp));
+}
+
+static apr_status_t test_read(void *env, apr_read_type_e block, 
+                              apr_off_t bytes)
+{
+    return APR_ENOTIMPL;
+}
+
+static const char *test_temp_dir(void *env, const char *path)
+{
+    static const char *temp_dir;
+    if (path != NULL) {
+        const char *rv = temp_dir;
+        temp_dir = apr_pstrdup(p, path);
+        return rv;
+    }
+    if (temp_dir == NULL) {
+        if (apr_temp_dir_get(&temp_dir, p) != APR_SUCCESS)
+            temp_dir = NULL;
+    }
+
+    return temp_dir;
+}
+
+
+static apr_off_t test_max_body(void *env, apr_off_t bytes)
+{
+    static apr_off_t max_body = -1;
+    if (bytes >= 0) {
+        apr_off_t rv = max_body;
+        max_body = bytes;
+        return rv;
+    }
+    return max_body;
+}
+
+
+static apr_ssize_t test_max_brigade(void *env, apr_ssize_t bytes)
+{
+    static apr_ssize_t max_brigade = -1;
+
+    if (bytes >= 0) {
+        apr_ssize_t rv = max_brigade;
+        max_brigade = bytes;
+        return rv;
+    }
+    return max_brigade;
+}
+
+
+
+APREQ_ENV_MODULE(test, APREQ_MODULE_NAME,
+                 APREQ_MODULE_MAGIC_NUMBER);
+

Modified: httpd/apreq/trunk/t/version.c
URL: http://svn.apache.org/viewcvs/httpd/apreq/trunk/t/version.c?view=diff&r1=153576&r2=153577
==============================================================================
--- httpd/apreq/trunk/t/version.c (original)
+++ httpd/apreq/trunk/t/version.c Sat Feb 12 15:04:35 2005
@@ -14,49 +14,58 @@
 **  limitations under the License.
 */
 
+#include "apreq_env.h"
 #include "apreq_version.h"
-#include "test_apreq.h"
-#include "apreq.h"
+#include "at.h"
 
-apr_version_t v;
-const char *vstring;
-
-static void version_string(CuTest *tc)
+static void version_string(dAT)
 {
-    vstring = apreq_version_string();
-    CuAssertPtrNotNull(tc, vstring);
-    CuAssertStrEquals(tc, APREQ_VERSION_STRING, vstring);
+    const char *vstring = apreq_version_string();
+    AT_not_null(vstring);
+    AT_str_eq(vstring, APREQ_VERSION_STRING);
 }
-static void version_major(CuTest *tc)
+static void version_type(dAT)
 {
+    apr_version_t v;
     apreq_version(&v);
-    CuAssertIntEquals(tc, APREQ_MAJOR_VERSION, v.major);
-}
-static void version_minor(CuTest *tc)
-{
-    CuAssertIntEquals(tc, APREQ_MINOR_VERSION, v.minor);
-}
-static void version_patch(CuTest *tc)
-{
-    CuAssertIntEquals(tc, APREQ_PATCH_VERSION, v.patch);
-}
-static void version_is_dev(CuTest *tc)
-{
+    AT_int_eq(v.major, APREQ_MAJOR_VERSION);
+    AT_int_eq(v.minor, APREQ_MINOR_VERSION);
+    AT_int_eq(v.patch, APREQ_PATCH_VERSION);
 #ifdef APREQ_IS_DEV_VERSION
-    CuAssertIntEquals(tc, 1, v.is_dev);
+    AT_int_eq(v.is_dev, 1);
 #else
-    CuAssertIntEquals(tc, 0, v.is_dev);
+    AT_int_eq(v.is_dev, 0);
 #endif
 }
 
-CuSuite *testversion(void)
+int main(int argc, char *argv[])
 {
-    CuSuite *suite = CuSuiteNew("Version");
-    SUITE_ADD_TEST(suite, version_string);
-    SUITE_ADD_TEST(suite, version_major);
-    SUITE_ADD_TEST(suite, version_minor);
-    SUITE_ADD_TEST(suite, version_patch);
-    SUITE_ADD_TEST(suite, version_is_dev);
-    return suite;
-}
+    extern const apreq_env_t test_module;
+    extern apr_pool_t *p;
+    int i, plan = 0;
+    dAT;
+    at_test_t test_list [] = {
+        {"version_string", version_string, 2, "1"},
+        {"version_type", version_type, 4}
+    };
 
+    apr_initialize();
+    atexit(apr_terminate);
+    apreq_env_module(&test_module);
+
+    apr_pool_create(&p, NULL);
+
+    AT = at_create(p, 0, at_report_stdout_make(p)); 
+
+    for (i = 0; i < sizeof(test_list) / sizeof(at_test_t);  ++i)
+        plan += test_list[i].plan;
+
+    AT_begin(plan);
+
+    for (i = 0; i < sizeof(test_list) / sizeof(at_test_t);  ++i)
+        AT_run(&test_list[i]);
+
+    AT_end();
+
+    return 0;
+}



Mime
View raw message