test_client_strope.c

Go to the documentation of this file.

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

#include <stdint.h>

#include <hipc/client.h>

static void test_strcspn(void)
{
    assert(0 == strcspn("", ""));
    assert(0 == strcspn("", "a"));
    assert(1 == strcspn("a", ""));
    assert(0 == strcspn("", "abc"));
    assert(3 == strcspn("abc", ""));
    assert(0 == strcspn("a", "abc"));
    assert(0 == strcspn("abc", "a"));
    assert(1 == strcspn("abc", "b"));
    assert(2 == strcspn("abc", "c"));
    assert(3 == strcspn("abc", "x"));

    assert(8 == strcspn("test_ctl.enable", "."));

    return;
}

static void test_arysize(void)
{
    struct {
        int32_t i;
        int8_t a;
    } sary[3][5];               /* ary of structs */

    uint8_t bary[7][9];         /* ary of bytes */

    assert(sizeof(sary[0]) == 5 * sizeof(sary[0][0]));
    assert(sizeof(sary) == 3 * 5 * sizeof(sary[0][0]));

    assert(sizeof(bary[0]) == 9 * sizeof(bary[0][0]));
    assert(sizeof(bary) == 7 * 9 * sizeof(bary[0][0]));

    return;
}

/* Start of hipc_client static initialization */
const struct HIPC_cl_indp_mbr b_test_ctl[] = {
    {HIPC_MBR_SIMPLE, "enable"},
    {HIPC_MBR_SIMPLE, "diff"},
};

const size_t b_ary0_elm_max_idxs[] = { 2, 3, 4 };       /* ary0[4][3][2] */
const size_t b_ary1_elm_max_idxs[] = { 5 };
const struct HIPC_cl_indp_mbr b_test_sa[] = {
    {HIPC_MBR_ARRAY, "ary0", 0, 3, b_ary0_elm_max_idxs, HIPC_MBR_SIMPLE},
    {HIPC_MBR_ARRAY, "ary1", 0, 1, b_ary1_elm_max_idxs, HIPC_MBR_STRUCT,
     0},
    {HIPC_MBR_STRUCT, "ctl", 0},
};

const struct HIPC_cl_indp_mbr HIPCUD_pidctrl_indp_member_pid_ctrl[] = {
    {HIPC_MBR_SIMPLE, "dummy"},
    {HIPC_MBR_SIMPLE, "target"},
    {HIPC_MBR_SIMPLE, "enable"},
};

const size_t b_inv_elm_max_idxs[] = { 2 };
const struct HIPC_cl_indp_mbr b_inv[] = {
    {HIPC_MBR_ARRAY, "dim", 0, 0, NULL, HIPC_MBR_SIMPLE},
    {HIPC_MBR_ARRAY, "snode", 0, 1, b_inv_elm_max_idxs, 128},
    {HIPC_MBR_SIMPLE, "offset"},
};

const struct HIPC_cl_indp_stru b_indp_s[] = {
    {2, "test_ctl", b_test_ctl},
    {3, "sa", b_test_sa},
    {3, "pid_ctrl", HIPCUD_pidctrl_indp_member_pid_ctrl},
    {3, "inv", b_inv},
};
const struct HIPC_cl_indp b_indp = { NULL, 0, 5, 4, b_indp_s };

unsigned char b_test_ctl_offset[] = { 0, 4 };
unsigned char b_test_ctl_size[] = { 1, 4 };
unsigned char b_test_sa_offset[] = { 0, 24, 64 };
unsigned char b_test_sa_size[] = { 24, 40, 8 };
unsigned char HIPCUD_pidctrl_cmdp_pid_ctrl_offset[] = {
    0, 6, 7,
};
unsigned char HIPCUD_pidctrl_cmdp_pid_ctrl_size[] = {
    6, 1, 1,
};
unsigned char b_inv_offset[] = { 0, 4, 8 };
unsigned char b_inv_size[] = { 4, 4, 255 };

struct HIPC_cl_dp_stru b_cmdp_s[] = {
    {b_test_ctl_offset, b_test_ctl_size},
    {b_test_sa_offset, b_test_sa_size},
    {HIPCUD_pidctrl_cmdp_pid_ctrl_offset,
     HIPCUD_pidctrl_cmdp_pid_ctrl_size},
    {b_inv_offset, b_inv_size},
};

unsigned char HIPCUD_pidctrl_smdp_pid_ctrl_offset[] = {
    0, 8, 9,
};

unsigned char HIPCUD_pidctrl_smdp_pid_ctrl_size[] = {
    8, 1, 1,
};

struct HIPC_cl_dp_stru b_smdp_s[] = {
    {b_test_ctl_offset, b_test_ctl_size},
    {b_test_sa_offset, b_test_sa_size},
    {HIPCUD_pidctrl_smdp_pid_ctrl_offset,
     HIPCUD_pidctrl_smdp_pid_ctrl_size},
    {b_inv_offset, b_inv_size},
};

unsigned char b_cmdp_strctsizes[] = { 8, 72, 8, 12 };
unsigned char b_smdp_strctsizes[] = { 8, 72, 12, 12 };
struct HIPC_cl_dp b_cmdp =
    { 0x6c /* 'l' */ , b_cmdp_strctsizes, b_cmdp_s };
struct HIPC_cl_dp b_smdp =
    { 0x6c /* 'l' */ , b_smdp_strctsizes, b_smdp_s };


struct HIPC_client b_ri = {
    0,
    &b_indp,
    &b_cmdp,
    &b_smdp,
};

/* End of struct HIPC_client static initialization */

static void test_hipcClientGetStrutpl(void)
{
    unsigned char strctnum;
    size_t offset;
    size_t size;

    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientGetStrutpl(&b_ri, "inv.offset",
                                &strctnum, &offset, &size));

    assert(HIPC_ERR_INTERNAL_ERROR ==
           hipcClientGetStrutpl(&b_ri, "inv.dim[0]",
                                &strctnum, &offset, &size));
    assert(0 ==
           strcmp("Number of dimensions is zero: mbr_p->ary_dim is zero",
                  b_ri.err_detail_str));

    assert(HIPC_ERR_INTERNAL_ERROR ==   /* elm_type of snode has wrong value. */
           hipcClientGetStrutpl(&b_ri, "inv.snode[0][0]",
                                &strctnum, &offset, &size));
    assert(0 == strcmp("Invalid member type: invalid value in mbr_p->type",
                       b_ri.err_detail_str));

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "test_ctl",
                                &strctnum, &offset, &size));
    assert(0 == strctnum);

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "test_ctl.enable",
                                &strctnum, &offset, &size));
    assert(0 == strctnum);
    assert(0 == offset);
    assert(1 == size);

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "test_foo.ary[3].foo",
                                &strctnum, &offset, &size));
    assert(0 == strcmp("Unknown structure name: test_foo",
                       b_ri.err_detail_str));


    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa", &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(0 == offset);
    assert(72 == size);

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(0 == offset);
    assert(24 == size);

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[x]",
                                &strctnum, &offset, &size));
    assert(0 == strcmp("Failed to extract index from: [x]",
                       b_ri.err_detail_str));

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri,
                                "sa.ary0[18446744073709551616]",
                                &strctnum, &offset, &size));
    assert(0 ==
           strcmp("Failed to extract index from: [18446744073709551616]",
                  b_ri.err_detail_str));

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[0]",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(0 == offset);
    assert(6 == size);
    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[1]",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(6 == offset);
    assert(6 == size);
    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[3]",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(18 == offset);
    assert(6 == size);

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[4]",
                                &strctnum, &offset, &size));
    assert(0 ==
           strcmp("The index is out of range: [4]", b_ri.err_detail_str));

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0.1]",
                                &strctnum, &offset, &size));
    assert(0 ==
           strcmp("No left bracket following the array name: .1]",
                  b_ri.err_detail_str));

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[1[2]",
                                &strctnum, &offset, &size));
    assert(0 ==
           strcmp("No right bracket following the index number: [1[2]",
                  b_ri.err_detail_str));

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[1][2]",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(10 == offset);
    assert(2 == size);

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[1][2][0]",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(10 == offset);
    assert(1 == size);

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[1][2][0][0]",
                                &strctnum, &offset, &size));
    assert(0 == strcmp("Inappropriate string: [0]", b_ri.err_detail_str));
    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary0[1][2][0]foo",
                                &strctnum, &offset, &size));
    assert(0 == strcmp("Inappropriate string: foo", b_ri.err_detail_str));

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary1",
                                &strctnum, &offset, &size));
    assert(1 == strctnum);
    assert(24 == offset);
    assert(40 == size);

    assert(HIPC_SUCCESS == hipcClientGetStrutpl(&b_ri, "sa.ary1[2]",
                                                &strctnum, &offset,
                                                &size));
    assert(1 == strctnum);
    assert(40 == offset);
    assert(8 == size);

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "sa.ary1[2].diff", &strctnum,
                                &offset, &size));
    assert(1 == strctnum);
    assert(44 == offset);
    assert(4 == size);

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary1[2]diff",
                                &strctnum, &offset, &size));
    assert(0 ==
           strcmp("No period before the member name: diff",
                  b_ri.err_detail_str));

    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, "sa.ary1[3].foo",
                                &strctnum, &offset, &size));
    assert(0 == strcmp("Unknown member name: foo", b_ri.err_detail_str));

    assert(HIPC_SUCCESS ==
           hipcClientGetStrutpl(&b_ri, "pid_ctrl.target", &strctnum,
                                &offset, &size));
    assert(2 == strctnum);
    assert(8 == offset);
    assert(1 == size);

    return;
}

static void test_hipcClientGetStrutpl_tooLargeName(void)
{
    char buf[HIPC_IMG_ALLOCSIZE + 4];
    unsigned int i;
    const char *str;
    size_t offset;
    size_t size;
    unsigned char strctnum;

    for (i = 0; i < HIPC_IMG_ALLOCSIZE; ++i) {
        buf[i] = 'a';
    }
    buf[HIPC_IMG_ALLOCSIZE] = '.';
    buf[HIPC_IMG_ALLOCSIZE + 1] = '\0';
    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, buf, &strctnum, &offset, &size));
    str = hipcClientGetErrDtlStr(&b_ri);
    assert(0 == memcmp("Unknown structure name: ", str, 24));
    for (i = 24; i < HIPC_IMG_ALLOCSIZE - 1; ++i) {
        assert('a' == str[i]);
    }
    assert('\0' == str[HIPC_IMG_ALLOCSIZE - 1]);

    buf[0] = 's';
    buf[1] = 'a';
    buf[2] = '.';
    for (i = 3; i < HIPC_IMG_ALLOCSIZE + 3; ++i) {
        buf[i] = 'a';
    }
    buf[HIPC_IMG_ALLOCSIZE + 3] = '\0';
    assert(HIPC_ERR_INV_ID_STR ==
           hipcClientGetStrutpl(&b_ri, buf, &strctnum, &offset, &size));
    str = hipcClientGetErrDtlStr(&b_ri);
    assert(0 == memcmp("Unknown member name: ", str, 21));
    for (i = 21; i < HIPC_IMG_ALLOCSIZE - 1; ++i) {
        assert('a' == str[i]);
    }
    assert('\0' == str[HIPC_IMG_ALLOCSIZE - 1]);

    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_strcspn();
        test_arysize();
        break;
    case 'b':
        test_hipcClientGetStrutpl();
        break;
    case 'c':
        test_hipcClientGetStrutpl_tooLargeName();
        break;
    default:
        fprintf(stderr, "Invalid test_id: %s \n", argv[1]);
        exit(EXIT_FAILURE);
    }

    return 0;
}