Extend matchCommand unit test

Jan Breuer

2015-10-12 c913483d36e994e672d5f23d0d7d437e09d6c58f

 libscpi/test/test_parser.c

@@ -32,14 +32,14 @@

static scpi_result_t test_treeA(scpi_t* context) {

    SCPI_ResultInt(context, 10);
    SCPI_ResultInt32(context, 10);

    return SCPI_RES_OK;
}

static scpi_result_t test_treeB(scpi_t* context) {

    SCPI_ResultInt(context, 20);
    SCPI_ResultInt32(context, 20);

    return SCPI_RES_OK;
}
@@ -70,7 +70,7 @@
    { .pattern = "STATus:QUEStionable:ENABle?", .callback = SCPI_StatusQuestionableEnableQ,},

    { .pattern = "STATus:PRESet", .callback = SCPI_StatusPreset,},
    

    { .pattern = "TEXTfunction?", .callback = text_function,},

    { .pattern = "TEST:TREEA?", .callback = test_treeA,},
@@ -95,9 +95,11 @@
    memcpy(output_buffer + output_buffer_pos, data, len);
    output_buffer_pos += len;
    output_buffer[output_buffer_pos] = '\0';
    return len;
}

scpi_t scpi_context;

static void error_buffer_clear(void) {
    err_buffer[0] = 0;
    err_buffer_pos = 0;
@@ -112,7 +114,6 @@
    err_buffer_pos++;
}


static size_t SCPI_Write(scpi_t * context, const char * data, size_t len) {
    (void) context;

@@ -120,6 +121,8 @@
}

static scpi_result_t SCPI_Flush(scpi_t * context) {
    (void) context;

    return SCPI_RES_OK;
}

@@ -132,7 +135,10 @@
}

scpi_reg_val_t srq_val = 0;

static scpi_result_t SCPI_Control(scpi_t * context, scpi_ctrl_name_t ctrl, scpi_reg_val_t val) {
    (void) context;

    if (SCPI_CTRL_SRQ == ctrl) {
        srq_val = val;
    } else {
@@ -144,6 +150,8 @@
scpi_bool_t RST_executed = FALSE;

static scpi_result_t SCPI_Reset(scpi_t * context) {
    (void) context;

    RST_executed = TRUE;
    return SCPI_RES_OK;
}
@@ -164,16 +172,17 @@

scpi_t scpi_context = {
    .cmdlist = scpi_commands,
    .buffer = {
    .buffer =
    {
        .length = SCPI_INPUT_BUFFER_LENGTH,
        .data = scpi_input_buffer,
    },
    .interface = &scpi_interface,
    .registers = scpi_regs,
    .units = scpi_units_def,
    .idn = {"MA", "IN", NULL, "VER"},
    .idn =
    {"MA", "IN", NULL, "VER"},
};


static int init_suite(void) {
    SCPI_Init(&scpi_context);
@@ -216,7 +225,7 @@
    TEST_INPUT("*IDN?", "");
    TEST_INPUT("", "MA,IN,0,VER\r\n");
    output_buffer_clear();
    

    /* Test ctree traversal */
    TEST_INPUT("TEST:TREEA?;TREEB?\r\n", "10;20\r\n");
    output_buffer_clear();
@@ -278,7 +287,7 @@
    TEST_IEEE4882("*SRE?\r\n", "255\r\n");
    TEST_IEEE4882("*STB?\r\n", "0\r\n");
    TEST_IEEE4882("*ESR?\r\n", "1\r\n");
    

    srq_val = 0;
    TEST_IEEE4882("ABCD\r\n", ""); /* "Undefined header" cause command error */
    CU_ASSERT_EQUAL(srq_val, (STB_ESR | STB_SRQ | STB_QMA)); /* value of STB as service request */
@@ -287,24 +296,24 @@

    TEST_IEEE4882("*STB?\r\n", "68\r\n"); /* Error queue is still not empty */
    TEST_IEEE4882("*ESR?\r\n", "0\r\n");
    

    TEST_IEEE4882("SYST:ERR:NEXT?\r\n", "-113,\"Undefined header\"\r\n");
    TEST_IEEE4882("SYST:ERR:NEXT?\r\n", "0,\"No error\"\r\n");

    TEST_IEEE4882("*STB?\r\n", "0\r\n"); /* Error queue is now empty */
    

    RST_executed = FALSE;
    TEST_IEEE4882("*RST\r\n", "");
    CU_ASSERT_EQUAL(RST_executed, TRUE);

    TEST_IEEE4882("*TST?\r\n", "0\r\n");
    

    TEST_IEEE4882("*WAI\r\n", "");

    TEST_IEEE4882("SYSTem:VERSion?\r\n", "1999.0\r\n");
}

#define TEST_ParamInt(data, mandatory, expected_value, expected_result, expected_error_code) \
#define TEST_ParamInt32(data, mandatory, expected_value, expected_result, expected_error_code) \
{                                                                                       \
    int32_t value;                                                                      \
    scpi_bool_t result;                                                                 \
@@ -315,7 +324,7 @@
    scpi_context.param_list.lex_state.buffer = data;                                    \
    scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
    scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer;   \
    result = SCPI_ParamInt(&scpi_context, &value, mandatory);                           \
    result = SCPI_ParamInt32(&scpi_context, &value, mandatory);                         \
                                                                                        \
    errCode = SCPI_ErrorPop(&scpi_context);                                             \
    CU_ASSERT_EQUAL(result, expected_result);                                           \
@@ -325,18 +334,180 @@
    CU_ASSERT_EQUAL(errCode, expected_error_code);                                      \
}

static void testSCPI_ParamInt(void) {
    TEST_ParamInt("10", TRUE, 10, TRUE, 0);
    TEST_ParamInt("", FALSE, 0, FALSE, 0);
    TEST_ParamInt("10.5", TRUE, 10, TRUE, 0); // TODO: should be FALSE, -104
    TEST_ParamInt("#B101010", TRUE, 42, TRUE, 0);
    TEST_ParamInt("#H101010", TRUE, 1052688, TRUE, 0);
    TEST_ParamInt("#Q10", TRUE, 8, TRUE, 0);
static void testSCPI_ParamInt32(void) {
    TEST_ParamInt32("10", TRUE, 10, TRUE, 0);
    TEST_ParamInt32("", FALSE, 0, FALSE, 0);
    TEST_ParamInt32("10.5", TRUE, 10, TRUE, 0); // TODO: should be FALSE, -104
    TEST_ParamInt32("#B101010", TRUE, 42, TRUE, 0);
    TEST_ParamInt32("#H101010", TRUE, 1052688, TRUE, 0);
    TEST_ParamInt32("#Q10", TRUE, 8, TRUE, 0);

    TEST_ParamInt("", TRUE, 0, FALSE, -109); // missing parameter
    TEST_ParamInt("abcd", TRUE, 0, FALSE, -104); // Data type error
    TEST_ParamInt("10.5V", TRUE, 0, FALSE, -138);
    TEST_ParamInt("10V", TRUE, 0, FALSE, -138);
    TEST_ParamInt32("", TRUE, 0, FALSE, -109); // missing parameter
    TEST_ParamInt32("abcd", TRUE, 0, FALSE, -104); // Data type error
    TEST_ParamInt32("10.5V", TRUE, 0, FALSE, -138);
    TEST_ParamInt32("10V", TRUE, 0, FALSE, -138);

    // test range
    TEST_ParamInt32("2147483647", TRUE, 2147483647, TRUE, 0);
    TEST_ParamInt32("-2147483647", TRUE, -2147483647, TRUE, 0);
}

#define TEST_ParamUInt32(data, mandatory, expected_value, expected_result, expected_error_code) \
{                                                                                       \
    uint32_t value;                                                                     \
    scpi_bool_t result;                                                                 \
    int16_t errCode;                                                                    \
                                                                                        \
    SCPI_CoreCls(&scpi_context);                                                        \
    scpi_context.input_count = 0;                                                       \
    scpi_context.param_list.lex_state.buffer = data;                                    \
    scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
    scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer;   \
    result = SCPI_ParamUInt32(&scpi_context, &value, mandatory);                        \
                                                                                        \
    errCode = SCPI_ErrorPop(&scpi_context);                                             \
    CU_ASSERT_EQUAL(result, expected_result);                                           \
    if (expected_result) {                                                              \
        CU_ASSERT_EQUAL(value, expected_value);                                         \
    }                                                                                   \
    CU_ASSERT_EQUAL(errCode, expected_error_code);                                      \
}

static void testSCPI_ParamUInt32(void) {
    TEST_ParamUInt32("10", TRUE, 10, TRUE, 0);
    TEST_ParamUInt32("", FALSE, 0, FALSE, 0);
    TEST_ParamUInt32("10.5", TRUE, 10, TRUE, 0); // TODO: should be FALSE, -104
    TEST_ParamUInt32("#B101010", TRUE, 42, TRUE, 0);
    TEST_ParamUInt32("#H101010", TRUE, 1052688, TRUE, 0);
    TEST_ParamUInt32("#Q10", TRUE, 8, TRUE, 0);

    TEST_ParamUInt32("", TRUE, 0, FALSE, -109); // missing parameter
    TEST_ParamUInt32("abcd", TRUE, 0, FALSE, -104); // Data type error
    TEST_ParamUInt32("10.5V", TRUE, 0, FALSE, -138);
    TEST_ParamUInt32("10V", TRUE, 0, FALSE, -138);

    // test range
    TEST_ParamUInt32("2147483647", TRUE, 2147483647, TRUE, 0);
    TEST_ParamUInt32("4294967295", TRUE, 4294967295, TRUE, 0);
}

#define TEST_ParamInt64(data, mandatory, expected_value, expected_result, expected_error_code) \
{                                                                                       \
    int64_t value;                                                                      \
    scpi_bool_t result;                                                                 \
    int16_t errCode;                                                                    \
                                                                                        \
    SCPI_CoreCls(&scpi_context);                                                        \
    scpi_context.input_count = 0;                                                       \
    scpi_context.param_list.lex_state.buffer = data;                                    \
    scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
    scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer;   \
    result = SCPI_ParamInt64(&scpi_context, &value, mandatory);                         \
                                                                                        \
    errCode = SCPI_ErrorPop(&scpi_context);                                             \
    CU_ASSERT_EQUAL(result, expected_result);                                           \
    if (expected_result) {                                                              \
        CU_ASSERT_EQUAL(value, expected_value);                                         \
    }                                                                                   \
    CU_ASSERT_EQUAL(errCode, expected_error_code);                                      \
}

static void testSCPI_ParamInt64(void) {
    TEST_ParamInt64("10", TRUE, 10, TRUE, 0);
    TEST_ParamInt64("", FALSE, 0, FALSE, 0);
    TEST_ParamInt64("10.5", TRUE, 10, TRUE, 0); // TODO: should be FALSE, -104
    TEST_ParamInt64("#B101010", TRUE, 42, TRUE, 0);
    TEST_ParamInt64("#H101010", TRUE, 1052688, TRUE, 0);
    TEST_ParamInt64("#Q10", TRUE, 8, TRUE, 0);

    TEST_ParamInt64("", TRUE, 0, FALSE, -109); // missing parameter
    TEST_ParamInt64("abcd", TRUE, 0, FALSE, -104); // Data type error
    TEST_ParamInt64("10.5V", TRUE, 0, FALSE, -138);
    TEST_ParamInt64("10V", TRUE, 0, FALSE, -138);

    // test range
    TEST_ParamInt64("2147483647", TRUE, 2147483647LL, TRUE, 0);
    TEST_ParamInt64("-2147483647", TRUE, -2147483647LL, TRUE, 0);
    TEST_ParamInt64("9223372036854775807", TRUE, 9223372036854775807LL, TRUE, 0);
    TEST_ParamInt64("-9223372036854775807", TRUE, -9223372036854775807LL, TRUE, 0);
}

#define TEST_ParamUInt64(data, mandatory, expected_value, expected_result, expected_error_code) \
{                                                                                       \
    uint64_t value;                                                                     \
    scpi_bool_t result;                                                                 \
    int16_t errCode;                                                                    \
                                                                                        \
    SCPI_CoreCls(&scpi_context);                                                        \
    scpi_context.input_count = 0;                                                       \
    scpi_context.param_list.lex_state.buffer = data;                                    \
    scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
    scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer;   \
    result = SCPI_ParamUInt64(&scpi_context, &value, mandatory);                        \
                                                                                        \
    errCode = SCPI_ErrorPop(&scpi_context);                                             \
    CU_ASSERT_EQUAL(result, expected_result);                                           \
    if (expected_result) {                                                              \
        CU_ASSERT_EQUAL(value, expected_value);                                         \
    }                                                                                   \
    CU_ASSERT_EQUAL(errCode, expected_error_code);                                      \
}

static void testSCPI_ParamUInt64(void) {
    TEST_ParamUInt64("10", TRUE, 10, TRUE, 0);
    TEST_ParamUInt64("", FALSE, 0, FALSE, 0);
    TEST_ParamUInt64("10.5", TRUE, 10, TRUE, 0); // TODO: should be FALSE, -104
    TEST_ParamUInt64("#B101010", TRUE, 42, TRUE, 0);
    TEST_ParamUInt64("#H101010", TRUE, 1052688, TRUE, 0);
    TEST_ParamUInt64("#Q10", TRUE, 8, TRUE, 0);

    TEST_ParamUInt64("", TRUE, 0, FALSE, -109); // missing parameter
    TEST_ParamUInt64("abcd", TRUE, 0, FALSE, -104); // Data type error
    TEST_ParamUInt64("10.5V", TRUE, 0, FALSE, -138);
    TEST_ParamUInt64("10V", TRUE, 0, FALSE, -138);

    // test range
    TEST_ParamUInt64("2147483647", TRUE, 2147483647, TRUE, 0);
    TEST_ParamUInt64("4294967295", TRUE, 4294967295, TRUE, 0);
    TEST_ParamUInt64("9223372036854775807", TRUE, 9223372036854775807ULL, TRUE, 0);
    TEST_ParamUInt64("18446744073709551615", TRUE, 18446744073709551615ULL, TRUE, 0);
}


#define TEST_ParamFloat(data, mandatory, expected_value, expected_result, expected_error_code) \
{                                                                                       \
    float value;                                                                        \
    scpi_bool_t result;                                                                 \
    int16_t errCode;                                                                    \
                                                                                        \
    SCPI_CoreCls(&scpi_context);                                                        \
    scpi_context.input_count = 0;                                                       \
    scpi_context.param_list.lex_state.buffer = data;                                    \
    scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
    scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer;   \
    result = SCPI_ParamFloat(&scpi_context, &value, mandatory);                         \
                                                                                        \
    errCode = SCPI_ErrorPop(&scpi_context);                                             \
    CU_ASSERT_EQUAL(result, expected_result);                                           \
    if (expected_result) {                                                              \
        CU_ASSERT_DOUBLE_EQUAL(value, expected_value, 0.000001);                        \
    }                                                                                   \
    CU_ASSERT_EQUAL(errCode, expected_error_code);                                      \
}

static void testSCPI_ParamFloat(void) {
    TEST_ParamFloat("10", TRUE, 10, TRUE, 0);
    TEST_ParamFloat("", FALSE, 0, FALSE, 0);
    TEST_ParamFloat("10.5", TRUE, 10.5, TRUE, 0);
    TEST_ParamFloat("#B101010", TRUE, 42, TRUE, 0);
    TEST_ParamFloat("#H101010", TRUE, 1052688, TRUE, 0);
    TEST_ParamFloat("#Q10", TRUE, 8, TRUE, 0);
    TEST_ParamFloat("#HFFFFFF", TRUE, 0xFFFFFFu, TRUE, 0);

    TEST_ParamFloat("", TRUE, 0, FALSE, -109); // missing parameter
    TEST_ParamFloat("abcd", TRUE, 0, FALSE, -104); // Data type error
    TEST_ParamFloat("10.5V", TRUE, 0, FALSE, -138);
    TEST_ParamFloat("10V", TRUE, 0, FALSE, -138);
}

#define TEST_ParamDouble(data, mandatory, expected_value, expected_result, expected_error_code) \
@@ -526,6 +697,70 @@
    TEST_NumericListDouble("(12,5:6:3)", 2, FALSE, 0, 0, SCPI_EXPR_ERROR, SCPI_ERROR_EXPRESSION_PARSING_ERROR);
}

#define NOPAREN(...) __VA_ARGS__

#define TEST_ChannelList(data, index, val_len, expected_range, expected_dimensions, _expected_from, _expected_to, expected_result, expected_error_code) \
{                                                                                       \
    scpi_bool_t result;                                                                 \
    scpi_expr_result_t result2;                                                         \
    int16_t errCode;                                                                    \
    scpi_parameter_t param;                                                             \
    int32_t val_from[val_len], val_to[val_len];                                         \
    scpi_bool_t val_range;                                                              \
    int32_t expected_from[] = {NOPAREN _expected_from};                                 \
    int32_t expected_to[] = {NOPAREN _expected_to};                                     \
    size_t val_dimensions;                                                              \
                                                                                        \
    SCPI_CoreCls(&scpi_context);                                                        \
    scpi_context.input_count = 0;                                                       \
    scpi_context.param_list.lex_state.buffer = data;                                    \
    scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
    scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer;   \
    result = SCPI_Parameter(&scpi_context, &param, TRUE);                               \
    result2 = SCPI_ExprChannelListEntry(&scpi_context, &param, index, &val_range, val_from, val_to, val_len, &val_dimensions);\
    errCode = SCPI_ErrorPop(&scpi_context);                                             \
    CU_ASSERT_EQUAL(result2, expected_result);                                          \
    if (expected_result == SCPI_EXPR_OK) {                                              \
        CU_ASSERT_EQUAL(val_dimensions, expected_dimensions);                           \
        CU_ASSERT_EQUAL(val_range, expected_range);                                     \
        { size_t i; for(i = 0; (i < val_len) && (i < val_dimensions); i++) {            \
            CU_ASSERT_EQUAL(val_from[i], expected_from[i]);                             \
        }}                                                                              \
        if (expected_range) {                                                           \
            { size_t i; for(i = 0; (i < val_len) && (i < val_dimensions); i++) {        \
                CU_ASSERT_EQUAL(val_to[i], expected_to[i]);                             \
            }}                                                                          \
        }                                                                               \
    }                                                                                   \
    CU_ASSERT_EQUAL(errCode, expected_error_code);                                      \
}

static void testChannelList(void) {
    TEST_ChannelList("(1)", 0, 1, FALSE, 0, (0), (0), SCPI_EXPR_ERROR, SCPI_ERROR_EXPRESSION_PARSING_ERROR);

    TEST_ChannelList("(@1)", 0, 1, FALSE, 1, (1), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1)", 1, 1, FALSE, 0, (0), (0), SCPI_EXPR_NO_MORE, 0);

    TEST_ChannelList("(@1,2)", 0, 1, FALSE, 1, (1), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2)", 1, 1, FALSE, 1, (2), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2)", 2, 1, FALSE, 0, (0), (0), SCPI_EXPR_NO_MORE, 0);

    TEST_ChannelList("(@1,2:3)", 0, 1, FALSE, 1, (1), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2:3)", 1, 1, TRUE, 1, (2), (3), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2:3)", 2, 1, FALSE, 0, (0), (0), SCPI_EXPR_NO_MORE, 0);

    TEST_ChannelList("(@1,2!5:3!6)", 0, 2, FALSE, 1, (1), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2!5:3!6)", 1, 2, TRUE, 2, (2, 5), (3, 6), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2!5:3!6)", 2, 2, FALSE, 0, (0), (0), SCPI_EXPR_NO_MORE, 0);

    TEST_ChannelList("(@1,2!5:3!6)", 0, 1, FALSE, 1, (1), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2!5:3!6)", 1, 1, TRUE, 2, (2), (3), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2!5:3!6)", 2, 1, FALSE, 0, (0), (0), SCPI_EXPR_NO_MORE, 0);

    TEST_ChannelList("(@1,2!5:3!6!7)", 0, 2, FALSE, 1, (1), (0), SCPI_EXPR_OK, 0);
    TEST_ChannelList("(@1,2!5:3!6!7)", 1, 2, FALSE, 0, (0), (0), SCPI_EXPR_ERROR, SCPI_ERROR_EXPRESSION_PARSING_ERROR);
    TEST_ChannelList("(@1,2!5:3!6!7)", 2, 2, FALSE, 0, (0), (0), SCPI_EXPR_ERROR, SCPI_ERROR_EXPRESSION_PARSING_ERROR);
}

int main() {
    unsigned int result;
@@ -543,7 +778,11 @@
    }

    /* Add the tests to the suite */
    if ((NULL == CU_add_test(pSuite, "SCPI_ParamInt", testSCPI_ParamInt))
    if ((NULL == CU_add_test(pSuite, "SCPI_ParamInt32", testSCPI_ParamInt32))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamUInt32", testSCPI_ParamUInt32))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamInt64", testSCPI_ParamInt64))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamUInt64", testSCPI_ParamUInt64))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamFloat", testSCPI_ParamFloat))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamDouble", testSCPI_ParamDouble))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamCharacters", testSCPI_ParamCharacters))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamCopyText", testSCPI_ParamCopyText))
@@ -551,6 +790,7 @@
            || (NULL == CU_add_test(pSuite, "Error handling", testErrorHandling))
            || (NULL == CU_add_test(pSuite, "IEEE 488.2 Mandatory commands", testIEEE4882))
            || (NULL == CU_add_test(pSuite, "Numeric list", testNumericList))
            || (NULL == CU_add_test(pSuite, "Channel list", testChannelList))
            ) {
        CU_cleanup_registry();
        return CU_get_error();