test_client.c

Go to the documentation of this file.

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

#include <hipc/client.h>

const struct HIPC_cl_indp_mbr HIPCUD_test_indp_member_log[] = {
    {HIPC_MBR_SIMPLE, "tick"},
    {HIPC_MBR_SIMPLE, "count"},
    {HIPC_MBR_SIMPLE, "diff"},
};

const struct HIPC_cl_indp_mbr HIPCUD_test_indp_member_ctl[] = {
    {HIPC_MBR_SIMPLE, "enable"},
    {HIPC_MBR_SIMPLE, "diff"},
};

const struct HIPC_cl_indp_stru HIPCUD_test_indp_struct[] = {
    {3, "test_log", HIPCUD_test_indp_member_log},
    {2, "test_ctl", HIPCUD_test_indp_member_ctl},
};

const struct HIPC_cl_indp HIPCUD_test_indp = {
    NULL, 0, 5, 2, HIPCUD_test_indp_struct
};


unsigned char HIPCUD_test_cmdp_log_offset[] = {
    0, 4, 8,
};

unsigned char HIPCUD_test_cmdp_log_size[] = {
    2, 4, 4,
};

unsigned char HIPCUD_test_cmdp_ctl_offset[] = {
    0, 4,
};

unsigned char HIPCUD_test_cmdp_ctl_size[] = {
    1, 4,
};

struct HIPC_cl_dp_stru HIPCUD_test_cmdp_struct[] = {
    {HIPCUD_test_cmdp_log_offset, HIPCUD_test_cmdp_log_size},
    {HIPCUD_test_cmdp_ctl_offset, HIPCUD_test_cmdp_ctl_size},
};

unsigned char HIPCUD_test_structsizes[] = {
    12, 8,
};

struct HIPC_cl_dp HIPCUD_test_cmdp = {
    0x6c /* 'l' */ , HIPCUD_test_structsizes, HIPCUD_test_cmdp_struct
};

static void test_hipcClientInit(void)
{
    struct HIPC_client cl;
    struct HIPC_client clbase;
    struct HIPC_cl_indp indp;
    struct HIPC_cl_dp cmdp;
    struct HIPC_cl_dp smdp;
    unsigned char structsizes[] = { 8 };

    indp.n_struct = 1;
    cmdp.endian = 0x6c;         /* 'l' */
    smdp.endian = 0x6c;         /* 'l' */
    smdp.struct_size_p = structsizes;

    assert(HIPC_ERR_INV_BASE_CLIENT == hipcClientInit(&cl, NULL));

    clbase.indp_p = NULL;
    clbase.cmdp_p = NULL;
    clbase.smdp_p = NULL;
    assert(HIPC_ERR_INV_BASE_CLIENT == hipcClientInit(&cl, &clbase));
    clbase.indp_p = &indp;
    assert(HIPC_ERR_INV_BASE_CLIENT == hipcClientInit(&cl, &clbase));
    clbase.cmdp_p = &cmdp;
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    hipcClientTerminate(&cl);
    clbase.smdp_p = &smdp;
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    hipcClientTerminate(&cl);

    return;
}

static void msgWithStr(hipc_msg msg, unsigned char type,
                       unsigned char const hipc_errno,
                       char const *const str)
{
    size_t len;

    msg[HIPC_MSGHDR_BYTE_TYPE] = type;
    msg[HIPC_MSGHDR_BYTE_OFFSET] = hipc_errno;
    msg[HIPC_MSGHDR_BYTE_STRUNO] = HIPC_UNSTRU;
    if (NULL == str) {
        msg[HIPC_MSGHDR_BYTE_BDYSZ] = 0;
    } else {
        len = strlen(str);
        if (255 > len) {
            msg[HIPC_MSGHDR_BYTE_BDYSZ] = len + 1;
        } else {
            msg[HIPC_MSGHDR_BYTE_BDYSZ] = 255;
        }
        memcpy(&msg[HIPC_MSGHDR_SIZE], str, msg[HIPC_MSGHDR_BYTE_BDYSZ]);
    }
    return;
}

static void test_hipcClientFeedSysmsg(void)
{
    hipc_msg msg_ov;            /* overview */
    hipc_msg msg_os;            /* offset */
    hipc_msg msg_sz;            /* size */
    struct HIPC_client cl;
    struct HIPC_client clbase;
    struct HIPC_cl_dp cmdp;

    clbase.indp_p = &HIPCUD_test_indp;
    clbase.cmdp_p = &cmdp;
    clbase.smdp_p = NULL;

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    msg_ov[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_PUT;
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedSysmsg(&cl, msg_ov));
    assert(HIPC_ERR_PROTOCOL_VIOLATION == cl.hipc_errno);
    hipcClientTerminate(&cl);

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    msg_ov[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_SYS;
    msg_ov[HIPC_MSGHDR_BYTE_OFFSET] = 0xFF;
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedSysmsg(&cl, msg_ov));
    hipcClientTerminate(&cl);

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    msg_ov[HIPC_MSGHDR_BYTE_OFFSET] = HIPC_SYSMSG_TYPE_OVERVIEW;
    msg_ov[HIPC_MSGHDR_BYTE_STRUNO] = 0x6f;     /* 'o' */
    msg_ov[HIPC_MSGHDR_BYTE_BDYSZ] = 0;
    assert(HIPC_ERR_INV_ENDIAN == hipcClientFeedSysmsg(&cl, msg_ov));
    hipcClientTerminate(&cl);

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    msg_ov[HIPC_MSGHDR_BYTE_STRUNO] = 0x6c;     /* 'l' */
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedSysmsg(&cl, msg_ov));
    hipcClientTerminate(&cl);

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    msg_ov[HIPC_MSGHDR_BYTE_BDYSZ] = 2;
    msg_ov[HIPC_MSGHDR_SIZE] = 12;
    msg_ov[HIPC_MSGHDR_SIZE + 1] = 8;
    assert(HIPC_SUCCESS == hipcClientFeedSysmsg(&cl, msg_ov));
    assert(12 == cl.smdp_p->struct_size_p[0]);
    assert(8 == cl.smdp_p->struct_size_p[1]);
    hipcClientTerminate(&cl);

    msg_ov[HIPC_MSGHDR_BYTE_STRUNO] = 0x42;     /* 'B' */
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    assert(HIPC_SUCCESS == hipcClientFeedSysmsg(&cl, msg_ov));
    assert(12 == cl.smdp_p->struct_size_p[0]);
    assert(8 == cl.smdp_p->struct_size_p[1]);
    msg_os[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_SYS;
    msg_os[HIPC_MSGHDR_BYTE_OFFSET] = HIPC_SYSMSG_TYPE_OFFSET;
    msg_os[HIPC_MSGHDR_BYTE_STRUNO] = 1;
    msg_os[HIPC_MSGHDR_BYTE_BDYSZ] = 2;
    msg_os[HIPC_MSGHDR_SIZE] = 0;
    msg_os[HIPC_MSGHDR_SIZE + 1] = 4;
    assert(HIPC_SUCCESS == hipcClientFeedSysmsg(&cl, msg_os));
    assert(0 == cl.smdp_p->struct_p[1].offset_p[0]);
    assert(4 == cl.smdp_p->struct_p[1].offset_p[1]);
    msg_sz[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_SYS;
    msg_sz[HIPC_MSGHDR_BYTE_OFFSET] = HIPC_SYSMSG_TYPE_SIZE;
    msg_sz[HIPC_MSGHDR_BYTE_STRUNO] = 1;
    msg_sz[HIPC_MSGHDR_BYTE_BDYSZ] = 2;
    msg_sz[HIPC_MSGHDR_SIZE] = 1;
    msg_sz[HIPC_MSGHDR_SIZE + 1] = 4;
    assert(HIPC_SUCCESS == hipcClientFeedSysmsg(&cl, msg_sz));
    assert(1 == cl.smdp_p->struct_p[1].size_p[0]);
    assert(4 == cl.smdp_p->struct_p[1].size_p[1]);
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedSysmsg(&cl, msg_sz));
    hipcClientTerminate(&cl);

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &clbase));
    msg_os[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_SYS;
    msg_os[HIPC_MSGHDR_BYTE_OFFSET] = HIPC_SYSMSG_TYPE_OFFSET;
    msg_os[HIPC_MSGHDR_BYTE_STRUNO] = 99;
    msg_os[HIPC_MSGHDR_BYTE_BDYSZ] = 2;
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedSysmsg(&cl, msg_os));
    msg_os[HIPC_MSGHDR_BYTE_STRUNO] = 1;
    msg_os[HIPC_MSGHDR_BYTE_BDYSZ] = 1;
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedSysmsg(&cl, msg_os));

    return;
}

static enum HIPC_errno setupTestClient(struct HIPC_client *const cl_p)
{
    struct HIPC_client clbase;

    clbase.indp_p = &HIPCUD_test_indp;
    clbase.cmdp_p = &HIPCUD_test_cmdp;
    clbase.smdp_p = clbase.cmdp_p;
    assert(HIPC_SUCCESS == hipcClientInit(cl_p, &clbase));

    return HIPC_SUCCESS;
}

static void test_hipcClientFeedStrumsg(void)
{
    hipc_msg tmpmsg;
    struct HIPC_client cl;

    assert(HIPC_SUCCESS == setupTestClient(&cl));
    tmpmsg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_PUT;
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedStrumsg(&cl, tmpmsg));
    assert(HIPC_ERR_PROTOCOL_VIOLATION == cl.hipc_errno);
    hipcClientTerminate(&cl);

    tmpmsg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_SUCCESS;
    tmpmsg[HIPC_MSGHDR_BYTE_OFFSET] = 0;
    tmpmsg[HIPC_MSGHDR_BYTE_STRUNO] = 1;
    tmpmsg[HIPC_MSGHDR_BYTE_BDYSZ] = 1;
    tmpmsg[HIPC_MSGHDR_SIZE] = 7;
    assert(HIPC_SUCCESS == setupTestClient(&cl));
    assert(HIPC_SUCCESS == hipcClientFeedStrumsg(&cl, tmpmsg));
    assert(7 == cl.simg_pp[1][0]);
    hipcClientTerminate(&cl);

    tmpmsg[HIPC_MSGHDR_BYTE_STRUNO] = 0xff;
    assert(HIPC_SUCCESS == setupTestClient(&cl));
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedStrumsg(&cl, tmpmsg));
    hipcClientTerminate(&cl);

    tmpmsg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_CAST;
    tmpmsg[HIPC_MSGHDR_BYTE_OFFSET] = 0;
    tmpmsg[HIPC_MSGHDR_BYTE_STRUNO] = 0;
    tmpmsg[HIPC_MSGHDR_BYTE_BDYSZ] = 1;
    tmpmsg[HIPC_MSGHDR_SIZE] = 5;
    assert(HIPC_SUCCESS == setupTestClient(&cl));
    assert(HIPC_SUCCESS == hipcClientFeedStrumsg(&cl, tmpmsg));
    assert(5 == cl.simg_pp[0][0]);
    hipcClientTerminate(&cl);

    tmpmsg[HIPC_MSGHDR_BYTE_OFFSET] = 0xff;
    assert(HIPC_SUCCESS == setupTestClient(&cl));
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedStrumsg(&cl, tmpmsg));
    hipcClientTerminate(&cl);

    return;
}

static void test_hipcClientFeedUnstrumsgAsError(void)
{
    hipc_msg tmpmsg;
    struct HIPC_client cl;

    assert(HIPC_SUCCESS == setupTestClient(&cl));
    msgWithStr(tmpmsg, HIPC_MESSAGE_TYPE_QUIT, HIPC_ERR_S_INV_STRUNO,
               "abc");
    assert(HIPC_ERR_S_INV_STRUNO ==
           hipcClientFeedUnstrumsgAsError(&cl, tmpmsg));
    assert(HIPC_ERR_S_INV_STRUNO == cl.hipc_errno);
    assert(0 == memcmp("abc", cl.err_detail_str, 4));
    hipcClientTerminate(&cl);

    assert(HIPC_SUCCESS == setupTestClient(&cl));
    tmpmsg[HIPC_MSGHDR_BYTE_STRUNO] = 0;
    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientFeedUnstrumsgAsError(&cl, tmpmsg));
    assert(HIPC_ERR_PROTOCOL_VIOLATION == cl.hipc_errno);
    hipcClientTerminate(&cl);

    return;
}

static void test_hipcClientGetNsysmsg(void)
{
    struct HIPC_client cl;

    assert(HIPC_SUCCESS == setupTestClient(&cl));
    assert(5 == hipcClientGetNsysmsg(&cl));

    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_hipcClientInit();
        break;
    case 'b':
        test_hipcClientFeedSysmsg();
        break;
    case 'c':
        test_hipcClientFeedStrumsg();
        break;
    case 'd':
        test_hipcClientFeedUnstrumsgAsError();
        break;
    case 'e':
        test_hipcClientGetNsysmsg();
        break;
    default:
        fprintf(stderr, "Invalid test_id: %s \n", argv[1]);
        exit(EXIT_FAILURE);
    }

    return 0;
}