test_mockio.c

Go to the documentation of this file.

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

#include <mockio.h>

#define S HIPC_SUCCESS
#define R 0
#define W 1

static void test_mockio(void)
{
    unsigned char buf[HIPC_IMG_ALLOCSIZE];
    struct MockIO mio;
    int i;

    struct MockIOOp ops[] = {
        {R, S, 0},
        {W, S, 0},
        {R, S, 4, {2, 3, 5, 7}},
        {W, S, 3, {11, 13, 17}},
        {R, HIPC_ERR_IO_READ, 1, {6}},
        {W, HIPC_ERR_IO_WRITE, 1, {30}},
        {W, S, 1, {23}},
    };
    mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
    assert(0 == mockIOCheckCompletion(&mio));

    for (i = 0; i < sizeof(buf); ++i) {
        buf[i] = 19;
    }

    assert(S == mockIORead(&mio, buf, 0));
    for (i = 0; i < sizeof(buf); ++i) {
        assert(19 == buf[i]);
    }
    assert(0 == mockIOCheckCompletion(&mio));

    assert(S == mockIOWrite(&mio, buf, 0));
    for (i = 0; i < sizeof(buf); ++i) {
        assert(19 == buf[i]);
    }
    assert(0 == mockIOCheckCompletion(&mio));

    assert(S == mockIORead(&mio, buf, 4));
    assert(2 == buf[0]);
    assert(3 == buf[1]);
    assert(5 == buf[2]);
    assert(7 == buf[3]);
    for (i = 4; i < sizeof(buf); ++i) {
        assert(19 == buf[i]);
    }
    assert(0 == mockIOCheckCompletion(&mio));

    buf[0] = 11;
    buf[1] = 13;
    buf[2] = 17;
    assert(S == mockIOWrite(&mio, buf, 3));
    assert(0 == mockIOCheckCompletion(&mio));

    assert(HIPC_ERR_IO_READ == mockIORead(&mio, buf, 1));
    assert(6 == buf[0]);
    assert(0 == mockIOCheckCompletion(&mio));

    buf[0] = 30;
    assert(HIPC_ERR_IO_WRITE == mockIOWrite(&mio, buf, 1));
    assert(0 == mockIOCheckCompletion(&mio));

    buf[0] = 23;
    assert(S == mockIOWrite(&mio, buf, 1));
    assert(1 == mockIOCheckCompletion(&mio));

    return;
}

static void test_mockIORead_err(void)
{
    unsigned char buf[HIPC_IMG_ALLOCSIZE];
    struct MockIO mio;

    {
        mockIOInit(&mio, NULL, 0);
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIORead(&mio, buf, 0));
        assert(MOCK_ERR_OVERRUN == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 0},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIORead(&mio, buf, 0));
        assert(MOCK_ERR_OPCODE == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {R, S, 0},
            {R, S, 0},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIORead(&mio, buf, 1));
        assert(MOCK_ERR_SIZE == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }

    return;
}

static void test_mockIOWrite_err(void)
{
    unsigned char buf[HIPC_IMG_ALLOCSIZE];
    struct MockIO mio;

    {
        mockIOInit(&mio, NULL, 0);
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIOWrite(&mio, buf, 0));
        assert(MOCK_ERR_OVERRUN == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {R, S, 0},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIOWrite(&mio, buf, 0));
        assert(MOCK_ERR_OPCODE == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 0},
            {W, S, 0},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIOWrite(&mio, buf, 1));
        assert(MOCK_ERR_SIZE == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 1, {2}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        buf[0] = 3;
        assert(HIPC_ERR_TEST_LIB_INTERNAL == mockIOWrite(&mio, buf, 1));
        assert(MOCK_ERR_DATA == mio.mock_errno);
        assert(-1 == mockIOCheckCompletion(&mio));
    }

    return;
}

int main(int argc, char *argv[])
{
    if (2 != argc) {
        fprintf(stderr, "Usage: %s test_id\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    switch (argv[1][0]) {
    case 'a':
        test_mockio();
        break;
    case 'b':
        test_mockIORead_err();
        break;
    case 'c':
        test_mockIOWrite_err();
        break;
    default:
        fprintf(stderr, "Invalid test_id: %s \n", argv[1]);
        exit(EXIT_FAILURE);
    }

    return 0;
}