Index: ossp-pkg/sio/Makefile.in
RCS File: /v/ossp/cvs/ossp-pkg/sio/Makefile.in,v
rcsdiff -q -kk '-r1.3' '-r1.4' -u '/v/ossp/cvs/ossp-pkg/sio/Makefile.in,v' 2>/dev/null
--- Makefile.in	2003/01/06 19:04:56	1.3
+++ Makefile.in	2003/01/20 19:13:39	1.4
@@ -51,7 +51,7 @@
 POD2MAN     = pod2man
 
 LIB_NAME    = libsio.la
-LIB_OBJS    = sio.lo sio_bio.lo sio_buffer.lo sio_hello.lo sio_null.lo sio_sa.lo sio_sillymux.lo sio_sio.lo sio_zlib.lo
+LIB_OBJS    = sio.lo sio_bio.lo sio_buffer.lo sio_hello.lo sio_null.lo sio_hole.lo sio_fd.lo sio_sa.lo sio_sillymux.lo sio_sio.lo sio_zlib.lo
 LIB_DEPS    = @LIB_DEPS@
 
 MAN_NAME    = sio.3
Index: ossp-pkg/sio/sio_test.c
RCS File: /v/ossp/cvs/ossp-pkg/sio/sio_test.c,v
rcsdiff -q -kk '-r1.7' '-r1.8' -u '/v/ossp/cvs/ossp-pkg/sio/sio_test.c,v' 2>/dev/null
--- sio_test.c	2003/01/20 15:34:13	1.7
+++ sio_test.c	2003/01/20 19:13:39	1.8
@@ -25,167 +25,352 @@
 **  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 **  SUCH DAMAGE.
 **
-**  sio_test.c: test suite
+**  sio_test.c: stream I/O library test suite
 */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifndef ENABLE_BIO
-#error Test requires BIO + SSL
-#endif
-
 #include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
 
+#include "ts.h"
 #include "al.h"
 #include "sio.h"
 
-#include "sa.h"
-
+#if ENABLE_BIO
 #include <openssl/ssl.h>
 #include <openssl/bio.h>
 extern BIO_METHOD *BIO_s_socket();
-
 extern sio_module_t sio_module_bio;
-extern sio_module_t sio_module_hello;
-extern sio_module_t sio_module_buffer;
-#ifndef SINK
-extern sio_module_t sio_module_sa;
 #endif
 
-#define e(f) rc = f; printf("%s = %s\n",#f, sio_error(rc)); fflush(stdout);
-#define s(f) src = f; printf("%s = %s\n",#f, sa_error(src)); fflush(stdout);
-#define n(f) rn = f; printf("%s = %d\n",#f, rn); fflush(stdout);
-#define p(f) rp = f; printf("%s = %p\n",#f, rp); fflush(stdout);
-
-int main(int argc, char *argv[])
-{
-    int rn;
-    void *rp;
-    sio_rc_t rc;
-    sio_t *sio;
-#ifndef SINK
-    sio_stage_t *sios_sa;
+#if ENABLE_SA
+#include "sa.h"
+extern sio_module_t sio_module_sa;
 #endif
-    sio_stage_t *sios_bio, *sios_hello, *sios_buffer;
 
-    sa_rc_t src;
-    sa_addr_t *saa;
-    sa_t *msa, *sa;
-    char *uri;
-
-    int fd;
-    SSL_CTX *ctx;
-#ifdef SINK
-    BIO *bio;
-#endif
-    BIO *sbio;
+extern sio_module_t sio_module_null;
+extern sio_module_t sio_module_hole;
+extern sio_module_t sio_module_buffer;
+extern sio_module_t sio_module_zlib;
+extern sio_module_t sio_module_sio;
+extern sio_module_t sio_module_fd;
+extern sio_module_t sio_module_hello;
+extern sio_module_t sio_module_sillymux;
 
-    char buf[] = "Hello world\n";
 
-    size_t actual;
-    size_t buflen;
-    int no  = 0;
-    int yes = 1;
+#define EVAL(name,rc,rc0,block) \
+    ts_test_check(TS_CTX, name); \
+    block \
+    if (rc != rc0) \
+        ts_test_fail(TS_CTX, "%s -> %d[%s] (expected %d[%s])\n", \
+            rc, sio_error(rc), rc0, sio_error(rc0))
 
-    s(sa_create(&msa));
-    s(sa_option(msa, SA_OPTION_REUSEADDR, 1));
+#define EVAL0(name,block) EVAL(name,rc,SIO_OK,block)
 
-    s(sa_addr_create(&saa));
-    uri = "inet://localhost:25001#tcp";
-    s(sa_addr_u2a(saa, uri));
-    s(sa_bind(msa,saa));
-    s(sa_addr_destroy(saa));
-    uri = NULL;
+sio_rc_t readloop(sio_t *sio, char *buf, size_t len, size_t *actualp)
+{
+    sio_rc_t rc;
+    size_t actual, total = 0;
 
-    ERR_load_BIO_strings();
-    OpenSSL_add_ssl_algorithms();
-    ctx = SSL_CTX_new(SSLv23_server_method());
+    while (len > 0) {
+        rc = sio_read(sio, buf, len, &actual);
+        if (rc != SIO_OK)
+            break;
+        buf   += actual;
+        total += actual;
+        len   -= actual;
+    }
 
-    if (!SSL_CTX_use_certificate_file(ctx, "/u/mlelstv/ssl/server.crt", SSL_FILETYPE_PEM))
-        exit(98);
-    if (!SSL_CTX_use_PrivateKey_file(ctx, "/u/mlelstv/ssl/server.key", SSL_FILETYPE_PEM))
-        exit(99);
+    *actualp = total;
+    return rc;
+}
 
-    e(sio_create(&sio));
-    e(sio_create_stage(sio, &sio_module_bio,    &sios_bio));
-    e(sio_create_stage(sio, &sio_module_hello,  &sios_hello));
-    e(sio_create_stage(sio, &sio_module_buffer, &sios_buffer));
-#ifndef SINK
-    e(sio_create_stage(sio, &sio_module_sa,     &sios_sa));
-#endif
+TS_TEST(test_sio_buffer)
+{
+    sio_rc_t rc;
+    sio_t *sio;
+    sio_stage_t *sios_buffer, *sios_hole;
+    size_t bufsize = 1000;     /* output/input buffer size */
+    int i,wcount = 100;
+    char S[] = "Hello world\n";
+    size_t actual, len = strlen(S);
+
+    EVAL0("sio_create", {
+        rc = sio_create(&sio);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_create_stage(&sios_hole)", {
+        rc = sio_create_stage(sio, &sio_module_hole, &sios_hole);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_create_stage(&sios_buffer)", {
+        rc = sio_create_stage(sio, &sio_module_buffer, &sios_buffer);
+    });
+    if (rc != SIO_OK) return;
+
+    EVAL0("sio_configure_stage(sios_buffer, outputsize)", {
+        rc = sio_configure_stage(sio, sios_buffer, "outputsize", &bufsize);
+    });
+    if (rc != SIO_OK) return;
+
+    EVAL0("sio_attach(sios_hole)", {
+        rc = sio_attach(sio, sios_hole, SIO_MODE_WRITE);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_attach(sios_buffer)", {
+        rc = sio_attach(sio, sios_buffer, SIO_MODE_WRITE);
+    });
+    if (rc != SIO_OK) return;
+
+    for (i=0; i<wcount; ++i) {
+        EVAL0("sio_write", {
+            rc = sio_write(sio, S, len, &actual);
+        });
+        if (rc != SIO_OK) break;
+        if (actual != len) {
+            ts_test_fail(TS_CTX, "sio_write result %d (expected %d)\n",
+                (int)actual, (int)len);
+            break;
+        }
+    }
 
-    buflen = 256;
-    e(sio_configure_stage(sio, sios_bio, "inputsize", &buflen));
+    EVAL0("sio_detach(sios_hole)", {
+        rc = sio_detach(sio, sios_hole);
+    });
+    EVAL0("sio_detach(sios_buffer)", {
+        rc = sio_detach(sio, sios_buffer);
+    });
+
+    EVAL0("sio_destroy_stage", {
+        rc = sio_destroy_stage(sio, sios_buffer);
+    });
+    EVAL0("sio_destroy_stage(sios_hole)", {
+        rc = sio_destroy_stage(sio, sios_hole);
+    });
+    EVAL0("sio_destroy", {
+        rc = sio_destroy(sio);
+    });
+}
 
-    buflen = 1000;
-    e(sio_configure_stage(sio, sios_buffer, "outputsize", &buflen));
+TS_TEST(test_sio_fd)
+{
+    sio_rc_t rc;
+    sio_t *sio;
+    sio_stage_t *sios_buffer, *sios_fd;
+    size_t bufsize = 1000;     /* output buffer size */
+    size_t buflen  =   81;     /* fd input buffer size */
+    int fd;
+    int i,wcount = 100;
+    char S[] = "Hello world\n";
+    char buf[sizeof(S)];
+    size_t actual, len = strlen(S);
+    char tempfile[] = "./sio_test_tmpfile.XXXXXX";
+    int do_unlink = 0;
+
+    EVAL0("sio_create", {
+        rc = sio_create(&sio);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_create_stage(&sios_fd)", {
+        rc = sio_create_stage(sio, &sio_module_fd, &sios_fd);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_create_stage(&sios_buffer)", {
+        rc = sio_create_stage(sio, &sio_module_buffer, &sios_buffer);
+    });
+    if (rc != SIO_OK) return;
+
+    EVAL0("sio_configure_stage(sios_fd, buflen)", {
+        rc = sio_configure_stage(sio, sios_fd, "buflen", &buflen);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_configure_stage(sios_buffer)", {
+        rc = sio_configure_stage(sio, sios_buffer, "outputsize", &buflen);
+    });
+    if (rc != SIO_OK) return;
+    EVAL0("sio_configure_stage(sios_buffer, inputsize)", {
+        rc = sio_configure_stage(sio, sios_buffer, "inputsize", &bufsize);
+    });
+    if (rc != SIO_OK) return;
+
+    /*
+     * WRITE phase
+     */
+
+    mktemp(tempfile);
+    fd = open(tempfile, O_CREAT|O_EXCL|O_WRONLY, 0600);
+    if (fd < 0) {
+        ts_test_fail(TS_CTX, "cannot create temporary file \"%s\" (%s)\n",
+            tempfile, strerror(errno));
+    } else {
+        do_unlink = 1;
+        EVAL0("sio_configure_stage(sios_fd, fd)", {
+            rc = sio_configure_stage(sio, sios_fd, "fd", &fd);
+        });
+        if (rc != SIO_OK) goto badwrite;
+        EVAL0("sio_attach(sios_fd)", {
+            rc = sio_attach(sio, sios_fd, SIO_MODE_READWRITE);
+        });
+        if (rc != SIO_OK) goto badwrite;
+        EVAL0("sio_attach(sios_buffer)", {
+            rc = sio_attach(sio, sios_buffer, SIO_MODE_READWRITE);
+        });
+        if (rc != SIO_OK) goto badwrite2;
+
+        for (i=0; i<wcount; ++i) {
+            EVAL0("sio_write", {
+                rc = sio_write(sio, S, len, &actual);
+            });
+            if (rc != SIO_OK) break;
+            if (actual != len) {
+                ts_test_fail(TS_CTX, "sio_write result %d (expected %d)\n",
+                    (int)actual, (int)len);
+                break;
+            }
+        }
+
+        EVAL0("sio_push", {
+            rc = sio_push(sio);
+        });
+
+        EVAL0("sio_detach(sios_buffer)", {
+            rc = sio_detach(sio, sios_buffer);
+        });
+
+        badwrite2:
+        EVAL0("sio_detach(sios_fd)", {
+            rc = sio_detach(sio, sios_fd);
+        });
 
-    s(sa_listen(msa, 5));
+        badwrite:
+        close(fd);
+    }
 
-    for(;;) {
+    fd = open(tempfile, O_RDONLY);
+    if (fd < 0) {
+        ts_test_fail(TS_CTX, "cannot read temporary file \"%s\" (%s)\n",
+            tempfile, strerror(errno));
+    } else {
+        EVAL0("sio_configure_stage(sios_fd, fd)", {
+            rc = sio_configure_stage(sio, sios_fd, "fd", &fd);
+        });
+        if (rc != SIO_OK) goto badread;
+
+        EVAL0("sio_attach(sios_fd)", {
+            rc = sio_attach(sio, sios_fd, SIO_MODE_READWRITE);
+        });
+        if (rc != SIO_OK) goto badread;
+        EVAL0("sio_attach(sios_buffer)", {
+            rc = sio_attach(sio, sios_buffer, SIO_MODE_READWRITE);
+        });
+        if (rc != SIO_OK) goto badread2;
+
+        for (i=0; i<wcount; ++i) {
+            EVAL0("sio_read", {
+                rc = readloop(sio, buf, len, &actual);
+            });
+            if (rc != SIO_OK) break;
+            if (actual != len) {
+                ts_test_fail(TS_CTX, "sio_read result %d (expected %d)\n",
+                    (int)actual, (int)len);
+                break;
+            }
+            buf[actual] = '\0';
+            if (strcmp(buf, S)) {
+                ts_test_fail(TS_CTX, "sio_read data mismatch at loop %d\n",
+                    i);
+                break;
+            }
+        }
+
+        EVAL0("sio_detach(sios_buffer)", {
+            rc = sio_detach(sio, sios_buffer);
+        });
+
+        badread2:
+        EVAL0("sio_detach(sios_fd)", {
+            rc = sio_detach(sio, sios_fd);
+        });
 
-        s(sa_accept(msa, &saa, &sa));
-        s(sa_addr_a2u(saa, &uri));
-        printf("Connection from %s\n",uri);
-        s(sa_addr_destroy(saa));
+        badread:
+        close(fd);
+    }
 
-        p(sbio = BIO_new_ssl(ctx,0));
-        e(sio_configure_stage(sio, sios_bio, "bio", sbio));
+    if (do_unlink && unlink(tempfile) < 0) {
+        ts_test_fail(TS_CTX, "cannot unlink temporary file \"%s\" (%s)\n",
+            tempfile, strerror(errno));
+    }
 
-#ifdef SINK
-        s(sa_getfd(sa, &fd));
-        p(bio = BIO_new_socket(fd, 0));
-        p(BIO_push(sbio,bio));
-#else
-        e(sio_configure_stage(sio, sios_sa, "sa", sa));
-        buflen = 256;
-        e(sio_configure_stage(sio, sios_sa, "buflen", &buflen));
-        e(sio_configure_stage(sio, sios_bio, "issink", &no));
-#endif
-        e(sio_configure_stage(sio, sios_bio, "freebio", &yes));
+    /*
+     * common cleanup
+     */
+
+    EVAL0("sio_destroy_stage", {
+        rc = sio_destroy_stage(sio, sios_buffer);
+    });
+    EVAL0("sio_destroy_stage(sios_fd)", {
+        rc = sio_destroy_stage(sio, sios_fd);
+    });
+    EVAL0("sio_destroy", {
+        rc = sio_destroy(sio);
+    });
+}
 
+TS_TEST(test_sio_pipe)
+{
+}
 
-#ifndef SINK
-        e(sio_attach(sio, sios_sa, SIO_MODE_READWRITE));
-#endif
-        e(sio_attach(sio, sios_bio, SIO_MODE_READWRITE));
-        e(sio_attach(sio, sios_hello, SIO_MODE_READWRITE));
-        e(sio_attach(sio, sios_buffer, SIO_MODE_WRITE));
+TS_TEST(test_sio_sio)
+{
+}
 
-        e(sio_write(sio, buf, sizeof(buf)-1, &actual));
-        e(sio_push(sio));
+TS_TEST(test_sio_hello)
+{
+}
 
-        e(sio_detach(sio, sios_buffer));
-        e(sio_detach(sio, sios_hello));
-        e(sio_detach(sio, sios_bio));
-#ifndef SINK
-        e(sio_detach(sio, sios_sa));
-#endif
+TS_TEST(test_sio_zlib)
+{
+}
 
-#ifdef SINK
-        BIO_pop(bio);
-#endif
-        /* BIO_free(sbio); */
-#ifdef SINK
-        BIO_free(bio);
+#if ENABLE_SA
+TS_TEST(test_sio_sa)
+{
+}
 #endif
 
-        sa_destroy(sa);
-    }
-
-
-#ifndef SINK
-    e(sio_destroy_stage(sio, sios_sa));
+#if ENABLE_BIO
+TS_TEST(test_sio_bio)
+{
+}
 #endif
-    e(sio_destroy_stage(sio, sios_buffer));
-    e(sio_destroy_stage(sio, sios_hello));
-    e(sio_destroy_stage(sio, sios_bio));
 
-    e(sio_destroy(sio));
-
-    sa_destroy(msa);
+int main(int argc, char *argv[])
+{
+    ts_suite_t *ts;
+    int n;
 
-    return 0;
+    ts = ts_suite_new("OSSP sio (Stream I/O)");
+    ts_suite_test(ts, test_sio_buffer, "stream I/O buffering");
+    ts_suite_test(ts, test_sio_fd, "stream I/O file");
+    ts_suite_test(ts, test_sio_pipe, "stream I/O pipe");
+    ts_suite_test(ts, test_sio_sio, "stream I/O multiplexing");
+    ts_suite_test(ts, test_sio_hello, "stream I/O hello protocol");
+#if ENABLE_ZLIB
+    ts_suite_test(ts, test_sio_zlib, "stream I/O zlib compression");
+#endif
+#if ENABLE_SA
+    ts_suite_test(ts, test_sio_sa, "stream I/O socket abstraction");
+#endif
+#if ENABLE_BIO
+    ts_suite_test(ts, test_sio_bio, "stream I/O ssl adapter");
+#endif
+    n = ts_suite_run(ts);
+    ts_suite_free(ts);
+    return n;
 }