test_client_hndlr.c

Go to the documentation of this file.

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

#include <hipc/client.h>

/* Start of settings for a mock HIPC client */
struct s0 {
    char m0;
};
struct s1 {
    int m0;
};

enum {
    HIPCUD_s0,
    HIPCUD_s1
};

const struct HIPC_cl_indp_mbr
 HIPCUD_mock_CCFG_indp_member_s0[] = {
    {HIPC_MBR_SIMPLE, "m0"},
};

const struct HIPC_cl_indp_mbr
 HIPCUD_mock_CCFG_indp_member_s1[] = {
    {HIPC_MBR_SIMPLE, "m0"},
};

const struct HIPC_cl_indp_stru HIPCUD_mock_CCFG_indp_struct[]
    = {
    {1, "s0", HIPCUD_mock_CCFG_indp_member_s0},
    {1, "s1", HIPCUD_mock_CCFG_indp_member_s1},
};

const struct HIPC_cl_indp HIPCUD_mock_CCFG_indp = {
    NULL, 0, 5, 2,
    HIPCUD_mock_CCFG_indp_struct
};

unsigned char HIPCUD_mock_CCFG_cmdp_s0_offset[] = {
    offsetof(struct s0, m0),
};
unsigned char HIPCUD_mock_CCFG_cmdp_s0_size[] = {
    sizeof(char),
};

unsigned char HIPCUD_mock_CCFG_cmdp_s1_offset[] = {
    offsetof(struct s1, m0),
};
unsigned char HIPCUD_mock_CCFG_cmdp_s1_size[] = {
    sizeof(int),
};

struct HIPC_cl_dp_stru HIPCUD_mock_CCFG_cmdp_struct[] = {
    {HIPCUD_mock_CCFG_cmdp_s0_offset, HIPCUD_mock_CCFG_cmdp_s0_size},
    {HIPCUD_mock_CCFG_cmdp_s1_offset, HIPCUD_mock_CCFG_cmdp_s1_size},
};

unsigned char HIPCUD_mock_CCFG_structsizes[] = {
    sizeof(struct s0),
    sizeof(struct s1),
};
struct HIPC_cl_dp HIPCUD_mock_CCFG_cmdp =
    { '\0', HIPCUD_mock_CCFG_structsizes, HIPCUD_mock_CCFG_cmdp_struct };

const struct HIPC_client HIPCUD_mock_CCFG = {
    0,
    &HIPCUD_mock_CCFG_indp,
    &HIPCUD_mock_CCFG_cmdp,
    NULL,
    NULL
};

/* End of settings for a mock HIPC client */

static struct call_log {
    enum HIPC_errno (*hndlr_p) (struct HIPC_client *,
                                const hipc_msg, void *, void *);
    const void *msg_p;
    void *cimg;
    void *arg;
} cllg;

static enum HIPC_errno hndlr0(struct HIPC_client *cl_p, const hipc_msg msg,
                              void *cimg, void *arg)
{
    cllg.hndlr_p = hndlr0;
    cllg.msg_p = msg;
    cllg.cimg = cimg;
    cllg.arg = arg;

    return 5;
}

static enum HIPC_errno hndlr1(struct HIPC_client *cl_p, const hipc_msg msg,
                              void *cimg, void *arg)
{
    cllg.hndlr_p = hndlr1;
    cllg.msg_p = msg;
    cllg.cimg = cimg;
    cllg.arg = arg;

    return 7;
}

static void test_handler(void)
{
    struct HIPC_client cl;
    hipc_msg msg;
    int iarg;
    struct s1 is1;

    assert(HIPC_SUCCESS == hipcClientInit(&cl, &HIPCUD_mock_CCFG));
    cllg.hndlr_p = NULL;
    cllg.msg_p = NULL;
    cllg.cimg = NULL;
    cllg.arg = NULL;

    assert(HIPC_SUCCESS == hipcClientCallHandler(&cl, HIPCUD_s0, NULL));
    assert(NULL == cllg.hndlr_p);
    assert(NULL == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(NULL == cllg.arg);
    assert(HIPC_SUCCESS == hipcClientCallHandler(&cl, HIPCUD_s1, NULL));
    assert(NULL == cllg.hndlr_p);
    assert(NULL == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(NULL == cllg.arg);

    hipcClientSetHandler(&cl, HIPCUD_s0, hndlr0, NULL);
    assert(5 == hipcClientCallHandler(&cl, HIPCUD_s0, NULL));
    assert(hndlr0 == cllg.hndlr_p);
    assert(NULL == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(NULL == cllg.arg);
    assert(HIPC_SUCCESS == hipcClientCallHandler(&cl, HIPCUD_s1, NULL));
    assert(hndlr0 == cllg.hndlr_p);
    assert(NULL == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(NULL == cllg.arg);

    hipcClientSetHandler(&cl, HIPCUD_s1, hndlr1, &iarg);
    assert(5 == hipcClientCallHandler(&cl, HIPCUD_s0, msg));
    assert(hndlr0 == cllg.hndlr_p);
    assert(msg == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(NULL == cllg.arg);
    assert(7 == hipcClientCallHandler(&cl, HIPCUD_s1, NULL));
    assert(hndlr1 == cllg.hndlr_p);
    assert(NULL == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(&iarg == cllg.arg);

    hipcClientSetCimg(&cl, HIPCUD_s1, &is1);
    assert(7 == hipcClientCallHandler(&cl, HIPCUD_s1, msg));
    assert(hndlr1 == cllg.hndlr_p);
    assert(msg == cllg.msg_p);
    assert(&is1 == cllg.cimg);
    assert(&iarg == cllg.arg);
    assert(5 == hipcClientCallHandler(&cl, HIPCUD_s0, msg));
    assert(hndlr0 == cllg.hndlr_p);
    assert(msg == cllg.msg_p);
    assert(NULL == cllg.cimg);
    assert(NULL == cllg.arg);

    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_handler();
        break;
    default:
        fprintf(stderr, "Invalid test_id: %s \n", argv[1]);
        exit(EXIT_FAILURE);
    }

    return 0;
}