src/vfer_test_accept_queue.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 * @file   vfer_test_accept_queue.c
 * @author Ivan Beschastnikh
 * @brief  Test: Accept Queue [accept_queue] tester.
 *
 * This test tests accept_queue.c and accept_queue.h. It creates
 * accept queues, enqueues and dequeues messages from the queue,
 * making sure that everything is consistent and exhibits correct
 * behaviour. This is done for server.c which is the only user of
 * the accept_queue.
 *
 * -     02/02/06        ivan            Updated to be more concise and use new testing suite
 * -     08/02/05        ivan            Upgraded to work with new accept_queue
 * -     07/30/05        ivan            Added to doxygen doc sys 
 */

#include "vfer_tests.h"
#include "vfer_accept_queue.h"

accept_queue* ac;
packet* request;
int enqueuer_err;

/**
 * Thread to dequeue items from the queue
 * @param ptr not used
 */

void DeQueuerT(void* ptr) {
        queued_conn* qc;
        int num;                /* number of packets that queue holds at maximum */
        int count;              /* number of items dequeued so far */
        int num_failed;

        num_failed = 0;
        num = (int)ptr;
        count = 0;
        while (count != num && num_failed < 3) {
                qc = Accept_Queue_Dequeue(ac);
                if (qc == NULL) {
                        sleep(1); /* wait for enqueue to happen in EnQueuerT */
                        num_failed++;
                        continue;
                }
                TEST_CHECK((qc->fd == count), "DeQueuerT: testing data integrity (fd)");
                count++;
        }
        TEST_CHECK((count == num), "DeQueuerT couldn't dequeues appropriate number of elements from queue");
        return;
} /* DeQueuerT() */

/**
 * Thread to enquue items into the queue
 * @param ptr not used
 */
void EnQueuerT(void* ptr) {
        int i;
        int num;
        struct sockaddr sa;
        
        num = (int) ptr;
        enqueuer_err = 0;
        for (i = 0; i < num; i++) {
                /* note: we are enqueuing an element with fd = i */
                if (Accept_Queue_Enqueue (ac, i, sa, request) != 0) {
                        /* we can't use TEST_CHECK b/c it is not
                         * thread safe so we rely on a global var that
                         * is checked after both threads exit */
                        enqueuer_err = 1;
                }
        }
} /* EnQueuerT() */


/**
 * Main process. Ignores arguments, runs small initial test and then
 * starts threads to enqueue and dequeue items from a queue.
 */
int main(int argc, char** argv) {
        int i, j;
        queued_conn* qc;
        pthread_t tid1, tid2;
        struct sockaddr sa;
        int mem0, mem1;         /* for memory leak checking */
        
        TEST_INIT("TEST_AQ", "test_accept_queue.c", stdout, stdout);

        /* tests to make sure functions return errors on incorrect args */
        TEST_CHECK((Accept_Queue_Create(-10) == NULL), "aq create with negative backlog");
        TEST_CHECK((Accept_Queue_Create(0) == NULL), "aq create with zero backlog");

        /* test create\delete and test for memory leak in either call */
        for (i = 1; i < 102; i+=20) {
                mem0 = (int)(ReqMem); /* save req mem to check for aq create and delete memory leaks */
                TEST_CHECK(((ac = Accept_Queue_Create(i)) != NULL), "aq create with okay backlog");
                Accept_Queue_Delete (ac);
                mem1 = (int)(ReqMem);
                TEST_CHECK((mem0 == mem1), "memory leak in creating\\deleting aq");
        }

        /* test create, enqueue up to backlog, dequeue, and delete and memory leak in any of these */
        for (i = 50; i <= 100; i+=50) {

                mem0 = (int)(ReqMem);
                TEST_CHECK(((ac = Accept_Queue_Create(i)) != NULL), "aq create with okay backlog");
                
                /* enqueue maximum number of entries */
                for (j = 0; j < i; j++) {
                        ALLOC(request, packet*, packet, 1);
                        ALLOC(request->iov, struct iovec*, struct iovec, 1);
                        request->iovlen = 0;
                        TEST_CHECK((Accept_Queue_Enqueue (ac, i, sa, request) == 0) , "aq enqueue");
                }

                for (j = 0; j < i; j++) {
                        TEST_CHECK(((qc = Accept_Queue_Dequeue(ac)) != NULL), "aq dequeue");
                        RELEASE_PACK(qc->request);
                        RELEASE(qc, sizeof(queued_conn));
                }
                
                Accept_Queue_Delete (ac);
                mem1 = (int)(ReqMem);
                TEST_CHECK((mem0 == mem1), "memory leak in creating\\deleting aq");
        }

        
        /* now we test how the queue works by being queued by one thread and dequeued by another */

        /* create the queue and allocate the packet for the threads to use */
        TEST_CHECK((Accept_Queue_Create(30) != NULL), "aq create with 30 items");
        ALLOC(request, packet*, packet, 1);
        ALLOC(request->iov, struct iovec*, struct iovec, 1);
        request->iovlen = 0;
        
        pthread_create(&tid1, NULL, (void (*)) DeQueuerT, (void*)(30));
        pthread_create(&tid2, NULL, (void (*)) EnQueuerT, (void*)(30));
        TEST_CHECK((enqueuer_err == 0), "enqueuing thread failed to enqueue at some point");
        
        /* collect the threads */
        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);
        TEST_SUMMARY();
        
        return 0;
} /* main() */

---