test_client_pack.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>

#define IMG_SIZE 256U

/* Start of hipc_client static initialization */
const struct HIPC_cl_indp_mbr Mock_indp_member_s0[] = {
    {HIPC_MBR_SIMPLE, "m0"},
    {HIPC_MBR_SIMPLE, "m1"},
    {HIPC_MBR_SIMPLE, "m2"},
    {HIPC_MBR_SIMPLE, "m3"},
};
const struct HIPC_cl_indp_mbr Mock_indp_member_s1[] = {
    {HIPC_MBR_SIMPLE, "m0"},
    {HIPC_MBR_SIMPLE, "m1"},
};
const size_t Mock_indp_member_idxs_ary[] = { 3, 2 };
const size_t Mock_indp_member_idxs_as[] = { 2 };

const struct HIPC_cl_indp_mbr Mock_indp_member_base[]
    = {
    {HIPC_MBR_SIMPLE, "m0"},
    {HIPC_MBR_SIMPLE, "m1"},
    {HIPC_MBR_STRUCT, "stru", 0},
    {HIPC_MBR_ARRAY, "ary", 0, 2, Mock_indp_member_idxs_ary, HIPC_MBR_SIMPLE},
    {HIPC_MBR_ARRAY, "as",  0, 1, Mock_indp_member_idxs_as,  HIPC_MBR_STRUCT, 1},
    {HIPC_MBR_SIMPLE, "m5"},
};

const struct HIPC_cl_indp_stru Mock_indp_struct[] = {
    {4, "s0", Mock_indp_member_s0},
    {2, "s1", Mock_indp_member_s1},
    {6, "base", Mock_indp_member_base},
};

const struct HIPC_cl_indp Mock_indp = {
    NULL, 0, 7, 3, Mock_indp_struct
};

unsigned char Mock_smdp_s0_offset[] = { 0,1,2,3 };
unsigned char Mock_smdp_s0_size[]   = { 1,1,1,1 };
unsigned char Mock_cmdp_s0_offset[] = { 0,1,2,3 };
unsigned char Mock_cmdp_s0_size[]   = { 1,1,1,1 };
unsigned char Mock_smdp_s1_offset[] = { 0,2 };
unsigned char Mock_smdp_s1_size[]   = { 2,1 };
unsigned char Mock_cmdp_s1_offset[] = { 0,4 };
unsigned char Mock_cmdp_s1_size[]   = { 4,1 };
unsigned char Mock_smdp_base_offset[] = { 0,1,2,  6, 12,26 };
unsigned char Mock_smdp_base_size[]   = { 1,1,4,1*6,6*2, 4 };
unsigned char Mock_cmdp_base_offset[] = { 0,4,8, 12, 24,44 };
unsigned char Mock_cmdp_base_size[]   = { 1,4,4,1*6,8*2, 4 };

unsigned char Mock_lstructsizes[] = { 4,8,48 };
unsigned char Mock_rstructsizes[] = { 4,6,30 };

struct HIPC_cl_dp_stru Mock_cmdp_struct[] = {
    {Mock_cmdp_s0_offset, Mock_cmdp_s0_size},
    {Mock_cmdp_s1_offset, Mock_cmdp_s1_size},
    {Mock_cmdp_base_offset, Mock_cmdp_base_size},
};
struct HIPC_cl_dp_stru Mock_smdp_struct[] = {
    {Mock_smdp_s0_offset, Mock_smdp_s0_size},
    {Mock_smdp_s1_offset, Mock_smdp_s1_size},
    {Mock_smdp_base_offset, Mock_smdp_base_size},
};
struct HIPC_cl_dp Mock_cmdp =
    { '\0', Mock_lstructsizes, Mock_cmdp_struct };
struct HIPC_cl_dp Mock_smdp =
    { '\0', Mock_rstructsizes, Mock_smdp_struct };
struct HIPC_client mock = { 0, &Mock_indp, &Mock_cmdp, &Mock_smdp };
/* End of struct HIPC_client static initialization */

struct log {
    size_t scur_p;
    size_t ccur_p;
    size_t n;
};

struct {
    unsigned int nl;
    struct log l[256];
} lgr;

static void loggerInit()
{
    lgr.nl = 0;
    return;
}

static void loggerAdd(void *const scur_p, void *const ccur_p,
                      const size_t n)
{
    fprintf(stderr, "%d: scur_p, ccur_p, n: %lu, %lu, %lu\n", lgr.nl,
            (size_t) scur_p, (size_t) ccur_p, n);
    if (256 <= lgr.nl) {
        fprintf(stderr, "logger is full.");
        exit(EXIT_FAILURE);
    }
    lgr.l[lgr.nl].scur_p = (size_t) scur_p;
    lgr.l[lgr.nl].ccur_p = (size_t) ccur_p;
    lgr.l[lgr.nl].n = n;
    ++(lgr.nl);
    return;
}

static int loggerCmp(const struct log l[], const unsigned int nl)
{
    unsigned int i;

    if (nl != lgr.nl) {
#ifdef DEBUG
        fprintf(stderr, "different numbers of items: %u!=%u\n", nl,
                lgr.nl);
#endif
        return 1;
    }
    for (i = 0; i < nl; ++i) {
        if (l[i].scur_p != lgr.l[i].scur_p) {
#ifdef DEBUG
            fprintf(stderr, "i:%u, scur_p:%lu!=%lu\n", i, l[i].scur_p,
                    lgr.l[i].scur_p);
#endif
            return 1;
        }
        if (l[i].ccur_p != lgr.l[i].ccur_p) {
#ifdef DEBUG
            fprintf(stderr, "i:%u, ccur_p:%lu!=%lu\n", i, l[i].ccur_p,
                    lgr.l[i].ccur_p);
#endif
            return 1;
        }
        if (l[i].n != lgr.l[i].n) {
#ifdef DEBUG
            fprintf(stderr, "i:%u, n:%lu!=%lu\n", i, l[i].n, lgr.l[i].n);
#endif
            return 1;
        }
    }
    return 0;
}

static void test_logger(void)
{
    loggerInit();
    {
        assert(0 == loggerCmp(NULL, 0));
    }

    loggerInit();
    loggerAdd((void *) 1U, (void *) 2U, 3);
    {
        assert(0 != loggerCmp(NULL, 0));
    }
    {
        struct log l[] = { {0, 0, 0} };
        assert(0 != loggerCmp(l, sizeof(l) / sizeof(l[0])));
    }
    {
        struct log l[] = { {1, 0, 0} };
        assert(0 != loggerCmp(l, sizeof(l) / sizeof(l[0])));
    }
    {
        struct log l[] = { {1, 2, 0} };
        assert(0 != loggerCmp(l, sizeof(l) / sizeof(l[0])));
    }
    {
        struct log l[] = { {1, 2, 3} };
        assert(0 == loggerCmp(l, sizeof(l) / sizeof(l[0])));
    }

    loggerAdd((void *) 4U, (void *) 5U, 6);
    {
        struct log l[] = { {1, 2, 3} };
        assert(0 != loggerCmp(l, sizeof(l) / sizeof(l[0])));
    }
    {
        struct log l[] = { {1, 2, 3}, {4, 5, 6} };
        assert(0 == loggerCmp(l, sizeof(l) / sizeof(l[0])));
    }
    return;
}

static int routine_hipcClientEachMbr(const size_t offset,
                                     const size_t size,
                                     const struct log l[],
                                     const unsigned int nl)
{
    struct HIPC_client cl;
    struct HIPC_cl_indp_mbr mbr;
    unsigned char *scur_p = (void *) 1000;
    unsigned char *ccur_p = (void *) 2000;

    mbr.type = HIPC_MBR_STRUCT;
    mbr.struno = 2;

    loggerInit();
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &mock));
    assert(HIPC_SUCCESS == hipcClientEachMbr(&cl, &mbr,
                                             scur_p + offset,
                                             scur_p + offset + size,
                                             scur_p, ccur_p, 0, 0,
                                             loggerAdd));
    hipcClientTerminate(&cl);

    return loggerCmp(l, nl);
}

static void test_hipcClientEachMbr(void)
{
    assert(0 == routine_hipcClientEachMbr(0, 0, NULL, 0));
    {
        struct log l[]= {{1000, 2000, 1},
        };
        assert(0==routine_hipcClientEachMbr(0,1, l, sizeof(l)/sizeof(l[0])));
    }
    {
        struct log l[]= {{1000, 2000, 1},
                         {1001, 2004, 1},
        };
        assert(0==routine_hipcClientEachMbr(0,2, l, sizeof(l)/sizeof(l[0])));
    }
    {
        struct log l[]= {{1000, 2000, 1},
                         {1001, 2004, 1},
                         {1002, 2008, 1},
        };
        assert(0==routine_hipcClientEachMbr(0,3, l, sizeof(l)/sizeof(l[0])));
    }
    {
        struct log l[]= {{1012, 2024, 2},
                         {1014, 2028, 1},
                         {1018, 2032, 2},
                         {1020, 2036, 1},
        };
        assert(0==routine_hipcClientEachMbr(12,12, l, sizeof(l)/sizeof(l[0])));
    }
    {
        struct log l[]= {{1007, 2013, 1},
                         {1008, 2014, 1},
                         {1009, 2015, 1},
                         {1010, 2016, 1},
                         {1011, 2017, 1},

                         {1012, 2024, 2},
                         {1014, 2028, 1},
                         {1018, 2032, 2},
        };
        assert(0==routine_hipcClientEachMbr(7,13, l, sizeof(l)/sizeof(l[0])));
    }
    {
        struct log l[]= {{1000, 2000, 1},
                         {1001, 2004, 1},

                         {1002, 2008, 1},
                         {1003, 2009, 1},
                         {1004, 2010, 1},
                         {1005, 2011, 1},

                         {1006, 2012, 1},
                         {1007, 2013, 1},
                         {1008, 2014, 1},
                         {1009, 2015, 1},
                         {1010, 2016, 1},
                         {1011, 2017, 1},

                         {1012, 2024, 2},
                         {1014, 2028, 1},
                         {1018, 2032, 2},
                         {1020, 2036, 1},

                         {1026, 2044, 4},
        };
        assert(0==routine_hipcClientEachMbr(0,30, l, sizeof(l)/sizeof(l[0])));
    }
    return;
}

/* Start of hipc_client static initialization */
const size_t Invmock_indp_member_idxs_ary[] = { 3 };

const struct HIPC_cl_indp_mbr Invmock_indp_member_base[]
    = {
    {0xff, "m0"},
    {HIPC_MBR_ARRAY, "a0", 0, 1, Invmock_indp_member_idxs_ary, HIPC_MBR_SIMPLE},
    {HIPC_MBR_ARRAY, "a1", 0, 1, Invmock_indp_member_idxs_ary, HIPC_MBR_SIMPLE},
    {HIPC_MBR_ARRAY, "a2", 0, 1, Invmock_indp_member_idxs_ary, 0xff},
};

const struct HIPC_cl_indp_stru Invmock_indp_struct[] = {
    {4, "base", Invmock_indp_member_base},
};

const struct HIPC_cl_indp Invmock_indp = {
    NULL, 0, 3, 1, Invmock_indp_struct
};

unsigned char Invmock_cmdp_base_offset[] = { 0,  1,  4, 8 };
unsigned char Invmock_cmdp_base_size[]   = { 1,1*3,  2, 3 };
unsigned char Invmock_smdp_base_offset[] = { 0,  1,  4, 8 };
unsigned char Invmock_smdp_base_size[]   = { 1,  2,1*3, 3 };
unsigned char Invmock_lstructsizes[] = { 12 };
unsigned char Invmock_rstructsizes[] = { 12 };

struct HIPC_cl_dp_stru Invmock_cmdp_struct[] = {
    {Invmock_cmdp_base_offset, Invmock_cmdp_base_size},
};
struct HIPC_cl_dp_stru Invmock_smdp_struct[] = {
    {Invmock_smdp_base_offset, Invmock_smdp_base_size},
};
struct HIPC_cl_dp Invmock_cmdp =
    { '\0', Invmock_lstructsizes, Invmock_cmdp_struct };
struct HIPC_cl_dp Invmock_smdp =
    { '\0', Invmock_rstructsizes, Invmock_smdp_struct };
struct HIPC_client invmock =
    { 0, &Invmock_indp, &Invmock_cmdp, &Invmock_smdp };
/* End of struct HIPC_client static initialization */

static void test_hipcClientEachMbr_err(void)
{
    struct HIPC_client cl;
    struct HIPC_cl_indp_mbr mbr;
    unsigned char *scur_p = (void *) 1000;
    unsigned char *ccur_p = (void *) 2000;
    size_t offset;
    size_t size;

    mbr.type = HIPC_MBR_STRUCT;
    mbr.struno = 0;

    offset = 0;
    size = 1;
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &invmock));
    assert(HIPC_ERR_INTERNAL_ERROR ==
           hipcClientEachMbr(&cl, &mbr,
                             scur_p + offset,
                             scur_p + offset + size,
                             scur_p, ccur_p, 0, 0, loggerAdd));
    hipcClientTerminate(&cl);

    offset = 1;
    size = 1;
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &invmock));
    assert(HIPC_ERR_INTERNAL_ERROR ==
           hipcClientEachMbr(&cl, &mbr,
                             scur_p + offset,
                             scur_p + offset + size,
                             scur_p, ccur_p, 0, 0, loggerAdd));
    hipcClientTerminate(&cl);

    offset = 4;
    size = 1;
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &invmock));
    assert(HIPC_ERR_INTERNAL_ERROR ==
           hipcClientEachMbr(&cl, &mbr,
                             scur_p + offset,
                             scur_p + offset + size,
                             scur_p, ccur_p, 0, 0, loggerAdd));
    hipcClientTerminate(&cl);

    /* Error in an element of a2 */
    offset = 8;
    size = 3;
    assert(HIPC_SUCCESS == hipcClientInit(&cl, &invmock));
    assert(HIPC_ERR_INTERNAL_ERROR ==
           hipcClientEachMbr(&cl, &mbr,
                             scur_p + offset,
                             scur_p + offset + size,
                             scur_p, ccur_p, 0, 0, loggerAdd));
    hipcClientTerminate(&cl);

    return;
}

static void test_hipcClientPack(void)
{
    unsigned char simg[IMG_SIZE];
    unsigned char cimg[IMG_SIZE];
    struct HIPC_client cl;
    unsigned int i;

    cl = mock;
    cl.endian_convert = 0;

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 0, 0, 0, simg, cimg));
    for (i = 0; i < IMG_SIZE; ++i) {
        assert(0x00 == simg[i]);
        assert(0xff == cimg[i]);
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 0, 0, 1, simg, cimg));
    assert(0xff == simg[0]);
    assert(0xff == cimg[0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        assert(0x00 == simg[i]);
        assert(0xff == cimg[i]);
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    cimg[4] = 0xff;
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 1, 2, 1, simg, cimg));
    for (i = 0; i < IMG_SIZE; ++i) {
        if (2 == i) {
            assert(0xff == simg[i]);
        } else {
            assert(0x00 == simg[i]);
        }
        if (4 == i) {
            assert(0xff == cimg[i]);
        } else {
            assert(0x00 == cimg[i]);
        }
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    cimg[44] = 0x01;
    cimg[45] = 0x02;
    cimg[46] = 0x03;
    cimg[47] = 0x04;
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 2, 26, 4, simg, cimg));
    assert(0x01 == simg[26]);
    assert(0x02 == simg[27]);
    assert(0x03 == simg[28]);
    assert(0x04 == simg[29]);
    assert(0x01 == cimg[44]);
    assert(0x02 == cimg[45]);
    assert(0x03 == cimg[46]);
    assert(0x04 == cimg[47]);
    for (i = 0; i < IMG_SIZE; ++i) {
        if (26 <= i && 30 > i) {
            assert(0x00 == cimg[i]);
        } else if (44 <= i && 48 > i) {
            assert(0x00 == simg[i]);
        } else {
            assert(0x00 == simg[i]);
            assert(0x00 == cimg[i]);
        }
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    cimg[44] = 0x01;
    cimg[45] = 0x02;
    cimg[46] = 0x03;
    cimg[47] = 0x04;
    cl.endian_convert = 1;
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 2, 26, 4, simg, cimg));
    assert(0x04 == simg[26]);
    assert(0x03 == simg[27]);
    assert(0x02 == simg[28]);
    assert(0x01 == simg[29]);
    assert(0x01 == cimg[44]);
    assert(0x02 == cimg[45]);
    assert(0x03 == cimg[46]);
    assert(0x04 == cimg[47]);
    for (i = 0; i < IMG_SIZE; ++i) {
        if (26 <= i && 30 > i) {
            assert(0x00 == cimg[i]);
        } else if (44 <= i && 48 > i) {
            assert(0x00 == simg[i]);
        } else {
            assert(0x00 == simg[i]);
            assert(0x00 == cimg[i]);
        }
    }

    return;
}

static void test_hipcClientPack_NULLarg(void)
{
    unsigned char iary[3][IMG_SIZE];
    unsigned char simg[IMG_SIZE];
    unsigned char cimg[IMG_SIZE];
    unsigned char *simg_pp[3];
    unsigned char *cimg_pp[3] = { NULL, NULL, NULL };
    struct HIPC_client cl;
    unsigned int i;
    unsigned int j;

    for (i = 0; i < 3; ++i) {
        simg_pp[i] = iary[i];
    }
    cl = mock;
    cl.endian_convert = 0;
    cl.simg_pp = simg_pp;
    cl.cimg_pp = cimg_pp;

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 0, 0, 1, NULL, cimg));
    assert(0xff == cimg[0]);
    assert(0xff == iary[0][0]);
    assert(0x00 == iary[1][0]);
    assert(0x00 == iary[2][0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
        assert(0xff == cimg[i]);
    }

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 0, 0, 1, NULL, NULL));
    for (i = 0; i < IMG_SIZE; ++i) {
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
    }

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    memset(cimg, 0xff, IMG_SIZE);
    hipcClientSetCimg(&cl, 0, &cimg);
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 0, 0, 1, NULL, NULL));
    assert(0xff == cimg[0]);
    assert(0xff == iary[0][0]);
    assert(0x00 == iary[1][0]);
    assert(0x00 == iary[2][0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
        assert(0xff == cimg[i]);
    }

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientPack(&cl, 0, 0, 1, simg, NULL));
    assert(0xff == simg[0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        assert(0x00 == simg[i]);
    }
    for (i = 0; i < IMG_SIZE; ++i) {
        assert(0xff == cimg[i]);
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
    }

    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientPack(&cl, 255, 255, 255, NULL, cimg));

    return;
}

static void test_hipcClientUnpack(void)
{
    unsigned char simg[IMG_SIZE];
    unsigned char cimg[IMG_SIZE];
    struct HIPC_client cl;
    unsigned int i;

    cl = mock;
    cl.endian_convert = 0;

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 0, 0, 0, simg, cimg));
    for (i = 0; i < IMG_SIZE; ++i) {
        assert(0x00 == simg[i]);
        assert(0xff == cimg[i]);
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 0, 0, 1, simg, cimg));
    assert(0x00 == simg[0]);
    assert(0x00 == cimg[0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        assert(0x00 == simg[i]);
        assert(0xff == cimg[i]);
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    simg[2] = 0xff;
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 1, 2, 1, simg, cimg));
    for (i = 0; i < IMG_SIZE; ++i) {
        if (2 == i) {
            assert(0xff == simg[i]);
        } else {
            assert(0x00 == simg[i]);
        }
        if (4 == i) {
            assert(0xff == cimg[i]);
        } else {
            assert(0x00 == cimg[i]);
        }
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    simg[26] = 0x01;
    simg[27] = 0x02;
    simg[28] = 0x03;
    simg[29] = 0x04;
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 2, 26, 4, simg, cimg));
    assert(0x01 == simg[26]);
    assert(0x02 == simg[27]);
    assert(0x03 == simg[28]);
    assert(0x04 == simg[29]);
    assert(0x01 == cimg[44]);
    assert(0x02 == cimg[45]);
    assert(0x03 == cimg[46]);
    assert(0x04 == cimg[47]);
    for (i = 0; i < IMG_SIZE; ++i) {
        if (26 <= i && 30 > i) {
            assert(0x00 == cimg[i]);
        } else if (44 <= i && 48 > i) {
            assert(0x00 == simg[i]);
        } else {
            assert(0x00 == simg[i]);
            assert(0x00 == cimg[i]);
        }
    }

    memset(simg, 0x00, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    simg[26] = 0x01;
    simg[27] = 0x02;
    simg[28] = 0x03;
    simg[29] = 0x04;
    cl.endian_convert = 1;
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 2, 26, 4, simg, cimg));
    assert(0x01 == simg[26]);
    assert(0x02 == simg[27]);
    assert(0x03 == simg[28]);
    assert(0x04 == simg[29]);
    assert(0x04 == cimg[44]);
    assert(0x03 == cimg[45]);
    assert(0x02 == cimg[46]);
    assert(0x01 == cimg[47]);
    for (i = 0; i < IMG_SIZE; ++i) {
        if (26 <= i && 30 > i) {
            assert(0x00 == cimg[i]);
        } else if (44 <= i && 48 > i) {
            assert(0x00 == simg[i]);
        } else {
            assert(0x00 == simg[i]);
            assert(0x00 == cimg[i]);
        }
    }

    assert(HIPC_ERR_PROTOCOL_VIOLATION ==
           hipcClientUnpack(&cl, 255, 255, 255, simg, cimg));

    return;
}

static void test_hipcClientUnpack_NULLarg(void)
{
    unsigned char iary[3][IMG_SIZE];
    unsigned char simg[IMG_SIZE];
    unsigned char cimg[IMG_SIZE];
    unsigned char *simg_pp[3];
    unsigned char *cimg_pp[3] = { NULL, NULL, NULL };
    struct HIPC_client cl;
    unsigned int i;
    unsigned int j;

    for (i = 0; i < 3; ++i) {
        simg_pp[i] = iary[i];
    }
    cl = mock;
    cl.endian_convert = 0;
    cl.simg_pp = simg_pp;
    cl.cimg_pp = cimg_pp;

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 0, 0, 1, NULL, cimg));
    assert(0x00 == cimg[0]);
    assert(0x00 == iary[0][0]);
    assert(0x00 == iary[1][0]);
    assert(0x00 == iary[2][0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
        assert(0xff == cimg[i]);
    }

    memset(cimg, 0xff, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 0, 0, 1, NULL, NULL));
    for (i = 0; i < IMG_SIZE; ++i) {
        assert(0xff == cimg[i]);
    }

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    memset(cimg, 0xff, IMG_SIZE);
    hipcClientSetCimg(&cl, 0, &cimg);
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 0, 0, 1, NULL, NULL));
    assert(0x00 == cimg[0]);
    assert(0x00 == iary[0][0]);
    assert(0x00 == iary[1][0]);
    assert(0x00 == iary[2][0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
        assert(0xff == cimg[i]);
    }

    for (j = 0; j < 3; ++j) {
        memset(iary[j], 0x00, IMG_SIZE);
    }
    memset(simg, 0xff, IMG_SIZE);
    memset(cimg, 0x00, IMG_SIZE);
    assert(HIPC_SUCCESS == hipcClientUnpack(&cl, 0, 0, 1, simg, NULL));
    assert(0xff == cimg[0]);
    for (i = 1; i < IMG_SIZE; ++i) {
        assert(0x00 == cimg[i]);
    }
    for (i = 0; i < IMG_SIZE; ++i) {
        assert(0xff == simg[i]);
        for (j = 0; j < 3; ++j) {
            assert(0x00 == iary[j][i]);
        }
    }

    return;
}

static void test_hipcClientCheckMbrSize(void)
{
    struct HIPC_client cl;
    const char *str;

    cl = mock;
    assert(HIPC_ERR_MBR_SIZE_MISMATCH == hipcClientCheckMbrSize(&cl));
    str = hipcClientGetErrDtlStr(&cl);
    assert(0 == strcmp("The member size in server is not the same "
                       "as the size in client; member name: m0", str));

    cl.smdp_p->struct_p[1].size_p[0] = cl.cmdp_p->struct_p[1].size_p[0];
    cl.smdp_p->struct_p[2].size_p[1] = cl.cmdp_p->struct_p[2].size_p[1];
    assert(HIPC_SUCCESS == hipcClientCheckMbrSize(&cl));

    cl.smdp_p->struct_p[2].size_p[2] =
        2 * cl.cmdp_p->struct_p[2].size_p[2];
    assert(HIPC_SUCCESS == hipcClientCheckMbrSize(&cl));

    cl.smdp_p->struct_p[2].size_p[3] =
        2 * cl.cmdp_p->struct_p[2].size_p[3];
    assert(HIPC_ERR_MBR_SIZE_MISMATCH == hipcClientCheckMbrSize(&cl));
    str = hipcClientGetErrDtlStr(&cl);
    assert(0 == strcmp("The member size in server is not the same "
                       "as the size in client; member name: ary", str));

    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_logger();
        break;
    case 'b':
        test_hipcClientEachMbr();
        break;
    case 'c':
        test_hipcClientEachMbr_err();
        break;
    case 'd':
        test_hipcClientPack();
        test_hipcClientPack_NULLarg();
        break;
    case 'e':
        test_hipcClientUnpack();
        test_hipcClientUnpack_NULLarg();
        break;
    case 'f':
        test_hipcClientCheckMbrSize();
        break;
    default:
        fprintf(stderr, "Invalid test_id: %s \n", argv[1]);
        exit(EXIT_FAILURE);
    }

    return 0;
}