test_session.c

Go to the documentation of this file.

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

#include <mock.h>
#include <hipc/session.h>

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

static enum HIPC_errno mockReadMsg(void *arg, hipc_msg msg)
{
    struct MockIO *mio_p = arg;
    enum HIPC_errno retval;

    retval = mockIORead(mio_p, msg, HIPC_MSGHDR_SIZE);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    if (0 < hipcMsgBdySize(msg)) {
        retval = mockIORead(mio_p, &msg[HIPC_MSGHDR_SIZE],
                            hipcMsgBdySize(msg));
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
    }

    return HIPC_SUCCESS;
}

static enum HIPC_errno mockWriteMsg(void *arg, const hipc_msg msg)
{
    struct MockIO *mio_p = arg;

    return mockIOWrite(mio_p, msg, hipcMsgTotalSize(msg));
}

static void openDefaultSession(hipc_session * const sess_p,
                               struct MockIO *mio_p)
{
    struct MOCK1S1 mstru;
    struct MockIOOp ops[] = {
        {W, S, 13, {HIPC_MESSAGE_TYPE_HELLO,HIPC_UNSTRU,0,9,
                    0x43,0x49,0x44,0x5f,0x4d,0x4f,0x43,0x4b,0x31}},
        {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,108,0,1}},
        {R, S, 1, {sizeof(mstru)}},
        {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,0,1,2}},
        {R, S, 2, {offsetof(struct MOCK1S1,m1),offsetof(struct MOCK1S1,m2)}},
        {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,0,2,2}},
        {R, S, 2, {sizeof(mstru.m1),sizeof(mstru.m2)}},
    };
    mockIOInit(mio_p, ops, sizeof(ops) / sizeof(ops[0]));
    hipcOpen(sess_p, &HIPCUD_cfgmock1_CCFG, mockReadMsg, mio_p,
             mockWriteMsg, mio_p);
    HIPC_ERRCHECK(sess_p);
    assert(1 == mockIOCheckCompletion(mio_p));

    return;
}

static void closeDefaultSession(hipc_session * const sess_p,
                                struct MockIO *mio_p)
{
    struct MockIOOp ops[] = {
        {W, S, 4, {HIPC_MESSAGE_TYPE_BYE, HIPC_UNSTRU, 0, 0}},
        {R, S, 4, {HIPC_MESSAGE_TYPE_QUIT, HIPC_UNSTRU, 0, 0}},
    };
    mockIOInit(mio_p, ops, sizeof(ops) / sizeof(ops[0]));
    hipcClose(sess_p);
    HIPC_ERRCHECK(sess_p);
    assert(1 == mockIOCheckCompletion(mio_p));

    return;
}

static void test_hipcSession(void)
{
    hipc_session sess;
    struct MockIO mio;
    char val;
    struct MOCK1S1 mstru;

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[] = {
            {W, S, 4, {HIPC_MESSAGE_TYPE_GET,HIPCUD_MOCK1S1,0,sizeof(mstru.m1)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPCUD_MOCK1S1,0,sizeof(mstru.m1)}},
            {R, S, 1, {5}},
        };
        assert(1 == sizeof(mstru.m1));
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        hipcGet(&sess, "MOCK1S1.m1", &val);
        HIPC_ERRCHECK(&sess);
        assert(5 == val);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 5, {HIPC_MESSAGE_TYPE_PUT,HIPCUD_MOCK1S1,0,sizeof(mstru.m1), 7}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPC_UNSTRU,0,0}},
        };
        assert(1 == sizeof(mstru.m1));
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        val = 7;
        hipcPut(&sess, "MOCK1S1.m1", &val);
        HIPC_ERRCHECK(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);    /* OPEN after CLOSE is OK. */
    closeDefaultSession(&sess, &mio);
    {                           /* CLOSE just after CLOSE is OK. */
        mockIOInit(&mio, NULL, 0);
        hipcClose(&sess);
        HIPC_ERRCHECK(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    assert(HIPC_ERR_INV_BASE_CLIENT ==
           hipcOpen(&sess, NULL, mockReadMsg, &mio, mockWriteMsg, &mio));
    assert(HIPC_ERR_SESS_STATE_MISMATCH == hipcGet(&sess, "MOCK1S1.m1", &val)); /* GET for a session that is not establised is NG. */
    hipcClose(&sess);

    return;
}

static enum HIPC_errno handler_MOCK2S1(struct HIPC_client *cl_p,
                                       const hipc_msg msg, void *cimg,
                                       void *arg)
{
    struct MOCK2S1 *stru_p;
    int *sum_p;

    assert(NULL != cimg);
    assert(NULL != arg);
    stru_p = cimg;
    sum_p = arg;

    (*sum_p) += (stru_p->m1);

    return HIPC_SUCCESS;
}

static enum HIPC_errno handler_msg(struct HIPC_client *cl_p,
                                   const hipc_msg msg, void *cimg,
                                   void *arg)
{
    assert(NULL == cimg);
    assert(NULL == arg);

    fprintf(stderr, "msg[4]: %d\n", msg[4]);
    return msg[4];
}

static void test_hipcSession_cast(void)
{
    hipc_session sess;
    struct MockIO mio;
    char val;
    struct MOCK2S1 m2s1;
    struct MOCK2S2 m2s2;
    int sum;

    assert(1 == sizeof(m2s1.m1));
    assert(0 == offsetof(struct MOCK2S1, m1));
    {
        struct MockIOOp ops[] = {
            {W, S, 13, {HIPC_MESSAGE_TYPE_HELLO,HIPC_UNSTRU,0,9,
                        0x43,0x49,0x44,0x5f,0x4d,0x4f,0x43,0x4b,0x32}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,108,0,2}},
            {R, S, 2, {sizeof(struct MOCK2S1), sizeof(struct MOCK2S2)}},

            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,0,1,1}},
            {R, S, 1, {offsetof(struct MOCK2S1,m1)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,0,2,1}},
            {R, S, 1, {sizeof(m2s1.m1)}},

            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,1,1,2}},
            {R, S, 2, {offsetof(struct MOCK2S2,m1),offsetof(struct MOCK2S2,m2)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,1,2,2}},
            {R, S, 2, {sizeof(m2s2.m1),sizeof(m2s2.m2)}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        hipcOpen(&sess, &HIPCUD_cfgmock2_CCFG, mockReadMsg, &mio,
                 mockWriteMsg, &mio);
        HIPC_ERRCHECK(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 4, {HIPC_MESSAGE_TYPE_GET,HIPCUD_MOCK2S2,0,sizeof(m2s2.m1)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK2S1,0,sizeof(m2s1)}},
            {R, S, sizeof(m2s1), {19}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPCUD_MOCK2S2,0,sizeof(m2s1.m1)}},
            {R, S, 1, {5}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        sum = 0;
        hipcGet(&sess, "MOCK2S2.m1", &val);
        HIPC_ERRCHECK(&sess);
        assert(0 == sum);
        assert(5 == val);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    hipcSetHandler(&sess, "MOCK2S1", &m2s1, handler_MOCK2S1, &sum);
    {
        struct MockIOOp ops[] = {
            {W, S, 4, {HIPC_MESSAGE_TYPE_GET,HIPCUD_MOCK2S2,0,sizeof(m2s2.m1)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK2S1,0,sizeof(m2s1)}},
            {R, S, sizeof(m2s1), {19}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPCUD_MOCK2S2,0,sizeof(m2s1.m1)}},
            {R, S, 1, {5}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        sum = 0;
        hipcGet(&sess, "MOCK2S2.m1", &val);
        HIPC_ERRCHECK(&sess);
        assert(19 == sum);
        assert(5 == val);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 5, {HIPC_MESSAGE_TYPE_PUT,HIPCUD_MOCK2S2,0,sizeof(m2s2.m1), 7}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK2S1,0,sizeof(m2s1)}},
            {R, S, sizeof(m2s1), {1}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK2S1,0,sizeof(m2s1)}},
            {R, S, sizeof(m2s1), {2}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK2S1,0,sizeof(m2s1)}},
            {R, S, sizeof(m2s1), {3}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPC_UNSTRU,0,0}},
        };
        assert(1 == sizeof(m2s2.m1));
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        val = 7;
        sum = 0;
        hipcPut(&sess, "MOCK2S2.m1", &val);
        assert(6 == sum);
        HIPC_ERRCHECK(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    hipcSetHandler(&sess, "MOCK2S1", NULL, handler_msg, NULL);
    {
        struct MockIOOp ops[] = {
            {W, S, 4, {HIPC_MESSAGE_TYPE_GET,HIPCUD_MOCK2S2,0,sizeof(m2s2.m1)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK2S1,0,sizeof(m2s1)}},
            {R, S, sizeof(m2s1), {HIPC_SUCCESS}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPCUD_MOCK2S2,0,sizeof(m2s1.m1)}},
            {R, S, 1, {5}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        hipcGet(&sess, "MOCK2S2.m1", &val);
        HIPC_ERRCHECK(&sess);
        assert(5 == val);
        assert(1 == mockIOCheckCompletion(&mio));
    }
    {
        struct MockIOOp ops[] = {
            {W, S, 4, {HIPC_MESSAGE_TYPE_BYE, HIPC_UNSTRU, 0, 0}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_QUIT, HIPC_UNSTRU, 0, 0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        hipcClose(&sess);
        HIPC_ERRCHECK(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    openDefaultSession(&sess, &mio);
    hipcSetHandler(&sess, "MOCK1S1", NULL, handler_msg, NULL);
    {                           /* When a handler returns error */
        struct MOCK1S1 m1s1;
        struct MockIOOp ops[] = {
            {W, S, 5, {HIPC_MESSAGE_TYPE_PUT,HIPCUD_MOCK1S1,0,sizeof(m1s1.m1), 7}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK1S1,0,sizeof(m1s1)}},
            {R, S, sizeof(m1s1), {HIPC_ERR_FOR_TESTING}},
        };
        assert(1 == sizeof(m1s1.m1));
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        val = 7;
        assert(HIPC_ERR_FOR_TESTING == hipcPut(&sess, "MOCK1S1.m1", &val));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    return;
}

static void test_hipcOpen_err(void)
{
    hipc_session sess;
    struct MockIO mio;
    struct MOCK1S1 mstru;

    assert(HIPC_ERR_INV_BASE_CLIENT ==
           hipcOpen(&sess, NULL, mockReadMsg, &mio, mockWriteMsg, &mio));
    hipcClose(&sess);

    {
        struct MockIOOp ops[] = {
            {W, HIPC_ERR_IO_WRITE, 13,
             {HIPC_MESSAGE_TYPE_HELLO, HIPC_UNSTRU, 0, 9,
              0x43, 0x49, 0x44, 0x5f, 0x4d, 0x4f, 0x43, 0x4b, 0x31}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_WRITE ==
               hipcOpen(&sess, &HIPCUD_cfgmock1_CCFG, mockReadMsg, &mio,
                        mockWriteMsg, &mio));
        hipcClose(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    {
        struct MockIOOp ops[]= {
            {W, S, 13, {HIPC_MESSAGE_TYPE_HELLO,HIPC_UNSTRU,0,9,
                        0x43,0x49,0x44,0x5f,0x4d,0x4f,0x43,0x4b,0x31}},
            {R, HIPC_ERR_IO_READ, 4, {HIPC_MESSAGE_TYPE_SYS,108,0,1}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_READ ==
               hipcOpen(&sess, &HIPCUD_cfgmock1_CCFG, mockReadMsg, &mio,
                        mockWriteMsg, &mio));
        hipcClose(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    {
        struct MockIOOp ops[] = {
            {W, S, 13, {HIPC_MESSAGE_TYPE_HELLO,HIPC_UNSTRU,0,9,
                        0x43,0x49,0x44,0x5f,0x4d,0x4f,0x43,0x4b,0x31}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_QUIT,HIPC_UNSTRU,HIPC_ERR_S_BUF_SHTG,0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_S_BUF_SHTG ==
               hipcOpen(&sess, &HIPCUD_cfgmock1_CCFG, mockReadMsg, &mio,
                        mockWriteMsg, &mio));
        hipcClose(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    {
        struct MockIOOp ops[] = {
            {W, S, 13, {HIPC_MESSAGE_TYPE_HELLO,HIPC_UNSTRU,0,9,
                        0x43,0x49,0x44,0x5f,0x4d,0x4f,0x43,0x4b,0x31}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,108,0,1}},
            {R, S, 1, {sizeof(mstru)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPC_UNSTRU,0,0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_PROTOCOL_VIOLATION ==
               hipcOpen(&sess, &HIPCUD_cfgmock1_CCFG, mockReadMsg, &mio,
                        mockWriteMsg, &mio));
        hipcClose(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    {
        struct MockIOOp ops[] = {
            {W, S, 13, {HIPC_MESSAGE_TYPE_HELLO,HIPC_UNSTRU,0,9,
                        0x43,0x49,0x44,0x5f,0x4d,0x4f,0x43,0x4b,0x31}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,108,0,1}},
            {R, S, 1, {sizeof(mstru)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,0,1,2}},
            {R, S, 2, {offsetof(struct MOCK1S1,m1),offsetof(struct MOCK1S1,m2)}},
            {R, S, 4, {HIPC_MESSAGE_TYPE_SYS,0,2,2}},
            {R, S, 2, {sizeof(mstru.m1),sizeof(mstru.m2)+1}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_MBR_SIZE_MISMATCH ==
               hipcOpen(&sess, &HIPCUD_cfgmock1_CCFG, mockReadMsg, &mio,
                        mockWriteMsg, &mio));
        hipcClose(&sess);
        assert(1 == mockIOCheckCompletion(&mio));
    }

    return;
}

static void test_hipcClose_err(void)
{
    hipc_session sess;
    struct MockIO mio;

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[] = {
            {W, HIPC_ERR_IO_WRITE, 4, {HIPC_MESSAGE_TYPE_BYE,HIPC_UNSTRU,0,0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_WRITE == hipcClose(&sess));
        assert(1 == mockIOCheckCompletion(&mio));
    }

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[]= {
            {W, S, 4, {HIPC_MESSAGE_TYPE_BYE,HIPC_UNSTRU,0,0}},
            {R, HIPC_ERR_IO_READ, 4, {HIPC_MESSAGE_TYPE_QUIT,HIPC_UNSTRU,0,0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_READ == hipcClose(&sess));
        assert(1 == mockIOCheckCompletion(&mio));
    }

    return;
}

static void test_hipcGet_err(void)
{
    hipc_session sess;
    struct MockIO mio;
    struct MOCK1S1 mstru;
    char val;

    sess.state = HIPC_SESS_TERMINATED;
    assert(HIPC_ERR_SESS_STATE_MISMATCH ==
           hipcGet(&sess, "MOCK1S1.m1", &val));

    openDefaultSession(&sess, &mio);
    assert(HIPC_ERR_INV_ID_STR == hipcGet(&sess, "X", &val));
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[] = {
            {W, HIPC_ERR_IO_WRITE, 4, {HIPC_MESSAGE_TYPE_GET,HIPCUD_MOCK1S1,0,sizeof(mstru.m1)}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_WRITE == hipcGet(&sess, "MOCK1S1.m1", &val));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[]= {
            {W, S, 4, {HIPC_MESSAGE_TYPE_GET,HIPCUD_MOCK1S1,0,sizeof(mstru.m1)}},
            {R, HIPC_ERR_IO_READ, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPCUD_MOCK1S1,0,sizeof(mstru.m1)}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_READ == hipcGet(&sess, "MOCK1S1.m1", &val));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    return;
}

static void test_hipcPut_err(void)
{
    hipc_session sess;
    struct MockIO mio;
    struct MOCK1S1 mstru;
    char val;

    val = 7;
    sess.state = HIPC_SESS_TERMINATED;
    assert(HIPC_ERR_SESS_STATE_MISMATCH ==
           hipcPut(&sess, "MOCK1S1.m1", &val));

    openDefaultSession(&sess, &mio);
    assert(HIPC_ERR_INV_ID_STR == hipcPut(&sess, "X", &val));
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[]= {
            {W, HIPC_ERR_IO_WRITE, 5, {HIPC_MESSAGE_TYPE_PUT,HIPCUD_MOCK1S1,0,sizeof(mstru.m1), 7}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_WRITE == hipcPut(&sess, "MOCK1S1.m1", &val));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[]= {
            {W, S, 5, {HIPC_MESSAGE_TYPE_PUT,HIPCUD_MOCK1S1,0,sizeof(mstru.m1), 7}},
            {R, HIPC_ERR_IO_READ, 4, {HIPC_MESSAGE_TYPE_SUCCESS,HIPC_UNSTRU,0,0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_IO_READ == hipcPut(&sess, "MOCK1S1.m1", &val));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    return;
}

static void test_hipcSetHandler_err(void)
{
    hipc_session sess;
    struct MockIO mio;

    sess.state = HIPC_SESS_TERMINATED;
    assert(HIPC_ERR_SESS_STATE_MISMATCH ==
           hipcSetHandler(&sess, "MOCK1S1.m1", NULL, NULL, NULL));

    openDefaultSession(&sess, &mio);
    assert(HIPC_ERR_INV_ID_STR ==
           hipcSetHandler(&sess, "X", NULL, NULL, NULL));
    closeDefaultSession(&sess, &mio);

    return;
}

static enum HIPC_errno handler_err(struct HIPC_client *cl_p,
                                   const hipc_msg msg, void *cimg,
                                   void *arg)
{
    return hipcClientSetError(cl_p, HIPC_ERR_FOR_TESTING, "handler_err");
}

static void test_hipcWaitReturn_err(void)
{
    hipc_session sess;
    struct MockIO mio;
    struct MOCK1S1 m1s1;
    hipc_msg msgR;

    sess.state = HIPC_SESS_TERMINATED;
    assert(HIPC_ERR_SESS_STATE_MISMATCH == hipcWaitReturn(&sess, msgR));

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[] = {
            {R, S, 4, {HIPC_MESSAGE_TYPE_BYE, HIPC_UNSTRU, 0, 0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_PROTOCOL_VIOLATION == hipcWaitReturn(&sess, msgR));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);
    {
        struct MockIOOp ops[] = {
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST, HIPC_UNSTRU, 0, 0}},
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_PROTOCOL_VIOLATION == hipcWaitReturn(&sess, msgR));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &mio);

    openDefaultSession(&sess, &mio);
    hipcSetHandler(&sess, "MOCK1S1", NULL, handler_err, NULL);
    {
        struct MockIOOp ops[]= {
            {R, S, 4, {HIPC_MESSAGE_TYPE_CAST,HIPCUD_MOCK1S1,0,sizeof(m1s1)}},
            {R, S, sizeof(m1s1), },
        };
        mockIOInit(&mio, ops, sizeof(ops) / sizeof(ops[0]));
        assert(HIPC_ERR_FOR_TESTING == hipcWaitReturn(&sess, msgR));
        assert(0 ==
               strcmp("handler_err", hipcClientGetErrDtlStr(&sess.cl)));
        assert(1 == mockIOCheckCompletion(&mio));
    }
    closeDefaultSession(&sess, &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_hipcSession();
        break;
    case 'b':
        test_hipcSession_cast();
        break;
    case 'c':
        test_hipcOpen_err();
        break;
    case 'd':
        test_hipcClose_err();
        break;
    case 'e':
        test_hipcGet_err();
        break;
    case 'f':
        test_hipcPut_err();
        break;
    case 'g':
        test_hipcSetHandler_err();
        break;
    case 'h':
        test_hipcWaitReturn_err();
        break;
    default:
        fprintf(stderr, "Invalid test_id: %s \n", argv[1]);
        exit(EXIT_FAILURE);
    }

    return 0;
}