1 #include "test.h"

     2 #include "../fifo.h"

     3 

     4 #include <sys/types.h>

     5 #include <sys/stat.h>

     6 #include <fcntl.h>

     7 #include <unistd.h>

     8 

     9 struct test_fifo_ctx {

    10     /** Path to the fifo */

    11     const char *path;

    12 

    13     /** The write end */

    14     int fd;

    15 

    16     /** callback invoked? */

    17     bool on_read;

    18 

    19     /** Still running? */

    20     bool run;

    21 };

    22 

    23 /**

    24  * Open the FIFO and write the test string to it

    25  */

    26 static void test_fifo_open_write (struct test_fifo_ctx *ctx)

    27 {

    28     // ...raw, for writing

    29     if ((ctx->fd = open(ctx->path, O_WRONLY)) < 0)

    30         FATAL_PERROR("open");

    31 

    32     // write something into it

    33     if (write(ctx->fd, "test", 4) != 4)

    34         FATAL_PERROR("write");

    35  

    36 }

    37 

    38 static void test_fifo_close (struct test_fifo_ctx *ctx)

    39 {

    40     close(ctx->fd);

    41     ctx->fd = -1;

    42 }

    43 

    44 static void test_fifo_on_read (transport_t *fifo, void *arg)

    45 {

    46     int ret;

    47     char buf[16];

    48     struct test_fifo_ctx *ctx = arg;

    49     error_t err;

    50 

    51     // read it back out

    52     log_info("test fifo_read");

    53     if ((ret = transport_read(fifo, buf, 16, &err)) < 0)

    54         assert_success(-ret);

    55 

    56     assert(ret == 4);

    57     assert_strncmp(buf, "test", 4);

    58  

    59     if (ctx->on_read) {

    60         test_fifo_close(ctx);

    61         ctx->run = false;

    62         return;

    63     }

    64    

    65     // re-open the fifo

    66     log_info("test fifo-re-open");

    67     test_fifo_close(ctx);

    68     test_fifo_open_write(ctx);

    69 

    70     ctx->on_read = true;

    71 }

    72 

    73 static struct transport_callbacks test_fifo_callbacks = {

    74     .on_read = test_fifo_on_read,

    75 };

    76 

    77 void test_fifo (void)

    78 {

    79     transport_t *fifo;

    80     struct error_info err;

    81     struct test_fifo_ctx _ctx, *ctx = &_ctx; memset(ctx, 0, sizeof(*ctx));

    82     struct transport_info info = { &test_fifo_callbacks, ctx, TRANSPORT_READ };

    83 

    84     // XXX: requires that this be run in a suitable CWD

    85     ctx->path = "test.fifo";

    86 

    87     // create the fifo

    88     if ((mkfifo(ctx->path, 0600) < 0) && (errno != EEXIST))

    89         FATAL_PERROR("mkfifo");

    90 

    91     // open it

    92     log_info("test fifo_open_read");

    93     assert_success(fifo_open_read(&info, &fifo, _test_ctx.ev_base, ctx->path, &err));

    94     

    95     // put some data into it

    96     test_fifo_open_write(ctx);

    97    

    98     // run the event loop

    99     log_debug("running the event loop...");

   100     ctx->run = true;

   101 

   102     while (ctx->run)

   103         assert(event_base_loop(_test_ctx.ev_base, EVLOOP_ONCE) == 0);

   104 

   105     // check

   106     assert(ctx->fd < 0);

   107     

   108     // cleanup

   109     transport_destroy(fifo);

   110 }

   111