messageqtest.c

Go to the documentation of this file.

/*
 * messageqtest.c
 *
 * Part of librfn (a general utility library from redfelineninja.org.uk)
 *
 * Copyright (C) 2013 Daniel Thompson <daniel@redfelineninja.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 */

#undef NDEBUG

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <librfn.h>

int queue_buf[3];
messageq_t queue = MESSAGEQ_VAR_INIT(
                queue_buf, sizeof(queue_buf), sizeof(queue_buf[0]));


int main()
{
        messageq_t myqueue;

        /*
         * The messageq_t data structure is intended to be safe to *send*
         * messages from multiple threads (although only one receiver thread
         * is permitted). However at present these tests only check for
         * sequential correctness.
         */

        /* prove the equivalence of the initializer and the init fn */
        messageq_init(&myqueue,
                        queue_buf, sizeof(queue_buf), sizeof(queue_buf[0]));
        verify(0 == memcmp(&queue, &myqueue, sizeof(queue)));

        /* simple claim, send, receive, release loop */
        for (int i=0; i<lengthof(queue_buf)*3; i++) {
                int *sendp = messageq_claim(&queue);
                verify(queue_buf + (i%lengthof(queue_buf)) == sendp);

                *sendp = i;
                messageq_send(&queue, sendp);

                int *receivep = messageq_receive(&queue);
                verify(sendp == receivep);
                verify(*receivep == i);

                messageq_release(&queue, receivep);
        }

        /* zealous claim with in-order sends and greedy receive */
        verify(queue_buf+0 == messageq_claim(&queue));
        verify(queue_buf+1 == messageq_claim(&queue));
        verify(queue_buf+2 == messageq_claim(&queue));
        verify(NULL == messageq_claim(&queue));

        messageq_send(&queue, queue_buf+0);
        verify(queue_buf+0 == messageq_receive(&queue));
        verify(NULL == messageq_receive(&queue));
        messageq_release(&queue, queue_buf+0);

        messageq_send(&queue, queue_buf+1);
        verify(queue_buf+1 == messageq_receive(&queue));
        verify(NULL == messageq_receive(&queue));
        messageq_release(&queue, queue_buf+1);

        messageq_send(&queue, queue_buf+2);
        verify(queue_buf+2 == messageq_receive(&queue));
        verify(NULL == messageq_receive(&queue));
        messageq_release(&queue, queue_buf+2);

        /* zealous claim with out-of-order sends and greedy receive */
        verify(queue_buf+0 == messageq_claim(&queue));
        verify(queue_buf+1 == messageq_claim(&queue));
        verify(queue_buf+2 == messageq_claim(&queue));
        verify(NULL == messageq_claim(&queue));

        messageq_send(&queue, queue_buf+2);
        verify(NULL == messageq_receive(&queue));

        messageq_send(&queue, queue_buf+1);
        verify(NULL == messageq_receive(&queue));

        messageq_send(&queue, queue_buf+0);
        verify(queue_buf+0 == messageq_receive(&queue));
        messageq_release(&queue, queue_buf+0);
        verify(queue_buf+1 == messageq_receive(&queue));
        messageq_release(&queue, queue_buf+1);
        verify(queue_buf+2 == messageq_receive(&queue));
        messageq_release(&queue, queue_buf+2);
        verify(NULL == messageq_receive(&queue));

        /* emptyness tests */
        verify(true == messageq_empty(&queue));

        verify(queue_buf+0 == messageq_claim(&queue));
        verify(true == messageq_empty(&queue));
        verify(queue_buf+1 == messageq_claim(&queue));
        verify(true == messageq_empty(&queue));
        verify(queue_buf+2 == messageq_claim(&queue));
        verify(true == messageq_empty(&queue));

        messageq_send(&queue, queue_buf+0);
        verify(false == messageq_empty(&queue));
        messageq_send(&queue, queue_buf+1);
        verify(false == messageq_empty(&queue));
        messageq_send(&queue, queue_buf+2);
        verify(false == messageq_empty(&queue));

        verify(queue_buf+0 == messageq_receive(&queue));
        verify(false == messageq_empty(&queue));
        messageq_release(&queue, queue_buf+0);
        verify(false == messageq_empty(&queue));
        verify(queue_buf+1 == messageq_receive(&queue));
        verify(false == messageq_empty(&queue));
        messageq_release(&queue, queue_buf+1);
        verify(false == messageq_empty(&queue));
        verify(queue_buf+2 == messageq_receive(&queue));
        verify(true == messageq_empty(&queue));
        messageq_release(&queue, queue_buf+2);
        verify(true == messageq_empty(&queue));

        return 0;
}