Add SCPI_ResultXYZ unit tests for basic types

Jan Breuer

2015-11-13 139d1e959364eccb361f7363815d386274bad8f0

Add SCPI_ResultXYZ unit tests for basic types

 libscpi/inc/scpi/parser.h

@@ -50,12 +50,12 @@

    size_t SCPI_ResultCharacters(scpi_t * context, const char * data, size_t len);
#define SCPI_ResultMnemonic(context, data) SCPI_ResultCharacters((context), (data), strlen(data))
#define SCPI_ResultUInt8Base SCPI_ResultUInt32Base
#define SCPI_ResultUInt8(c, v) SCPI_ResultUInt32Base((c), (v), 10)
#define SCPI_ResultInt8 SCPI_ResultInt32
#define SCPI_ResultUInt16Base SCPI_ResultUInt32Base
#define SCPI_ResultUInt16(c, v) SCPI_ResultUInt32Base((c), (v), 10)
#define SCPI_ResultInt16 SCPI_ResultInt32
#define SCPI_ResultUInt8Base(c, v, b) SCPI_ResultUInt32Base((c), (v), (uint8_t)(b))
#define SCPI_ResultUInt8(c, v) SCPI_ResultUInt32Base((c), (uint8_t)(v), 10)
#define SCPI_ResultInt8(c, v) SCPI_ResultInt32((c), (int8_t)(v))
#define SCPI_ResultUInt16Base(c, v, b) SCPI_ResultUInt32Base((c), (uint16_t)(v), (b))
#define SCPI_ResultUInt16(c, v) SCPI_ResultUInt32Base((c), (uint16_t)(v), 10)
#define SCPI_ResultInt16(c, v) SCPI_ResultInt32((c), (int16_t)(v))
    size_t SCPI_ResultUInt32Base(scpi_t * context, uint32_t val, int8_t base);
#define SCPI_ResultUInt32(c, v) SCPI_ResultUInt32Base((c), (v), 10)
    size_t SCPI_ResultInt32(scpi_t * context, int32_t val);

 libscpi/src/parser.c

@@ -53,7 +53,11 @@
 * @return number of bytes written
 */
static size_t writeData(scpi_t * context, const char * data, size_t len) {
    return context->interface->write(context, data, len);
    if (len > 0) {
        return context->interface->write(context, data, len);
    } else {
        return 0;
    }
}

/**
@@ -477,10 +481,17 @@
 */
size_t SCPI_ResultText(scpi_t * context, const char * data) {
    size_t result = 0;
    size_t len = strlen(data);
    const char * quote;
    result += writeDelimiter(context);
    result += writeData(context, "\"", 1);
    // TODO: convert " to ""
    result += writeData(context, data, strlen(data));
    while (quote = strnpbrk(data, len, "\"")) {
        result += writeData(context, data, quote - data + 1);
        result += writeData(context, "\"", 1);
        len -= quote - data + 1;
        data = quote + 1;
    }
    result += writeData(context, data, len);
    result += writeData(context, "\"", 1);
    context->output_count++;
    return result;
@@ -1433,7 +1444,7 @@
 * @param count
 * @param item_size
 * @param format
 * @return 
 * @return
 */
static size_t parserResultArrayBinary(scpi_t * context, const void * array, size_t count, size_t item_size, scpi_array_format_t format) {

@@ -1468,19 +1479,19 @@
                break;
            case 2:
                for (i = 0; i < count; i++) {
                    uint16_t val = SCPI_Swap16(((uint16_t*)array)[i]);
                    uint16_t val = SCPI_Swap16(((uint16_t*) array)[i]);
                    result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
                }
                break;
            case 4:
                for (i = 0; i < count; i++) {
                    uint32_t val = SCPI_Swap32(((uint32_t*)array)[i]);
                    uint32_t val = SCPI_Swap32(((uint32_t*) array)[i]);
                    result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
                }
                break;
            case 8:
                for (i = 0; i < count; i++) {
                    uint64_t val = SCPI_Swap64(((uint64_t*)array)[i]);
                    uint64_t val = SCPI_Swap64(((uint64_t*) array)[i]);
                    result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
                }
                break;
@@ -1537,7 +1548,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayInt16(scpi_t * context, const int16_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt16);
@@ -1549,7 +1560,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayUInt16(scpi_t * context, const uint16_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt16);
@@ -1561,7 +1572,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayInt32(scpi_t * context, const int32_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt32);
@@ -1573,7 +1584,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayUInt32(scpi_t * context, const uint32_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt32);
@@ -1585,7 +1596,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayInt64(scpi_t * context, const int64_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt64);
@@ -1597,7 +1608,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayUInt64(scpi_t * context, const uint64_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt64);
@@ -1609,7 +1620,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayFloat(scpi_t * context, const float * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultFloat);
@@ -1621,7 +1632,7 @@
 * @param array
 * @param count
 * @param format
 * @return 
 * @return
 */
size_t SCPI_ResultArrayDouble(scpi_t * context, const double * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultDouble);

 libscpi/test/test_parser.c

@@ -815,6 +815,203 @@
    TEST_ParamNumber("minc", TRUE, TRUE, SCPI_NUM_NUMBER, 0, SCPI_UNIT_NONE, 10, FALSE, SCPI_ERROR_ILLEGAL_PARAMETER_VALUE);
}

#define TEST_Result(func, value, expected_result) \
{\
    output_buffer_clear();\
    scpi_context.output_count = 0;\
    size_t expected_len = strlen(expected_result);\
    size_t len = SCPI_Result##func(&scpi_context, (value));\
    CU_ASSERT_EQUAL(len, expected_len);\
    CU_ASSERT_EQUAL(output_buffer_pos, expected_len);\
    CU_ASSERT_EQUAL(memcmp(output_buffer, expected_result, expected_len), 0);\
}

#define TEST_ResultBase(func, value, base, expected_result) \
{\
    output_buffer_clear();\
    scpi_context.output_count = 0;\
    size_t expected_len = strlen(expected_result);\
    size_t len = SCPI_Result##func##Base(&scpi_context, (value), (base));\
    CU_ASSERT_EQUAL(len, expected_len);\
    CU_ASSERT_EQUAL(output_buffer_pos, expected_len);\
    CU_ASSERT_EQUAL(memcmp(output_buffer, expected_result, expected_len), 0);\
}

static void testResultInt8(void) {
    TEST_Result(Int8, 10, "10");
    TEST_Result(Int8, -10, "-10");
    TEST_Result(Int8, 100, "100");
    TEST_Result(Int8, -100, "-100");
    TEST_Result(Int8, 256, "0");
    TEST_Result(Int8, 1111, "87");
    TEST_Result(Int8, 127, "127");
    TEST_Result(Int8, -128, "-128");
}

static void testResultUInt8(void) {
    TEST_Result(UInt8, 10, "10");
    TEST_Result(UInt8, -10, "246");
    TEST_Result(UInt8, 100, "100");
    TEST_Result(UInt8, -100, "156");
    TEST_Result(UInt8, 256, "0");
    TEST_Result(UInt8, 1111, "87");
    TEST_Result(UInt8, 127, "127");
    TEST_Result(UInt8, -128, "128");
    TEST_Result(UInt8, 0, "0");
    TEST_Result(UInt8, 255, "255");

    TEST_ResultBase(UInt8, 0xff, 16, "#HFF");
    TEST_ResultBase(UInt8, 0xff, 8, "#Q377");
    TEST_ResultBase(UInt8, 0xff, 2, "#B11111111");
}

static void testResultInt16(void) {
    TEST_Result(Int16, 10, "10");
    TEST_Result(Int16, -10, "-10");
    TEST_Result(Int16, 100, "100");
    TEST_Result(Int16, -100, "-100");
    TEST_Result(Int16, 256, "256");
    TEST_Result(Int16, 1111, "1111");
    TEST_Result(Int16, 127, "127");
    TEST_Result(Int16, -128, "-128");
    TEST_Result(Int16, 111111, "-19961");
    TEST_Result(Int16, 32767, "32767");
    TEST_Result(Int16, -32768, "-32768");
}

static void testResultUInt16(void) {
    TEST_Result(UInt16, 10, "10");
    TEST_Result(UInt16, -10, "65526");
    TEST_Result(UInt16, 100, "100");
    TEST_Result(UInt16, -100, "65436");
    TEST_Result(UInt16, 256, "256");
    TEST_Result(UInt16, 1111, "1111");
    TEST_Result(UInt16, 127, "127");
    TEST_Result(UInt16, -128, "65408");
    TEST_Result(UInt16, 111111, "45575");
    TEST_Result(UInt16, 32767, "32767");
    TEST_Result(UInt16, -32768, "32768");
    TEST_Result(UInt16, 65535, "65535");

    TEST_ResultBase(UInt16, 0xffff, 16, "#HFFFF");
    TEST_ResultBase(UInt16, 0xffff, 8, "#Q177777");
    TEST_ResultBase(UInt16, 0xffff, 2, "#B1111111111111111");
}

static void testResultInt32(void) {
    TEST_Result(Int32, 10, "10");
    TEST_Result(Int32, -10, "-10");
    TEST_Result(Int32, 2147483647, "2147483647");
    TEST_Result(Int32, -2147483648, "-2147483648");
}

static void testResultUInt32(void) {
    TEST_Result(UInt32, 10, "10");
    TEST_Result(UInt32, -10, "4294967286");
    TEST_Result(UInt32, 2147483647, "2147483647");
    TEST_Result(UInt32, -2147483648, "2147483648");
    TEST_Result(UInt32, 4294967295, "4294967295");

    TEST_ResultBase(UInt32, 0xffffffff, 16, "#HFFFFFFFF");
    TEST_ResultBase(UInt32, 0xffffffff, 8, "#Q37777777777");
    TEST_ResultBase(UInt32, 0xffffffff, 2, "#B11111111111111111111111111111111");
}

static void testResultInt64(void) {
    TEST_Result(Int64, 10, "10");
    TEST_Result(Int64, -10, "-10");
    TEST_Result(Int64, 127, "127");
    TEST_Result(Int64, -128, "-128");
    TEST_Result(Int64, 32767, "32767");
    TEST_Result(Int64, -32768, "-32768");
    TEST_Result(Int64, 2147483647, "2147483647");
    TEST_Result(Int64, -2147483648, "-2147483648");
    TEST_Result(Int64, 9223372036854775807LL, "9223372036854775807");
    //TEST_Result(Int64, -9223372036854775808LL, "-9223372036854775808"); bug in GCC
    TEST_Result(Int64, -9223372036854775807LL, "-9223372036854775807");
}

static void testResultUInt64(void) {
    TEST_Result(UInt64, 10, "10");
    TEST_Result(UInt64, -10, "18446744073709551606");
    TEST_Result(UInt64, 127, "127");
    TEST_Result(UInt64, -128, "18446744073709551488");
    TEST_Result(UInt64, 32767, "32767");
    TEST_Result(UInt64, -32768, "18446744073709518848");
    TEST_Result(UInt64, 2147483647, "2147483647");
    TEST_Result(UInt64, -2147483648, "18446744071562067968");
    TEST_Result(UInt64, 9223372036854775807LL, "9223372036854775807");
    //TEST_Result(Int64, -9223372036854775808LL, "9223372036854775808"); bug in GCC
    TEST_Result(UInt64, -9223372036854775807LL, "9223372036854775809");
    TEST_Result(UInt64, 18446744073709551615ULL, "18446744073709551615");

    TEST_ResultBase(UInt64, 0xffffffffffffffffULL, 16, "#HFFFFFFFFFFFFFFFF");
    TEST_ResultBase(UInt64, 0xffffffffffffffffULL, 8, "#Q1777777777777777777777");
    TEST_ResultBase(UInt64, 0xffffffffffffffffULL, 2, "#B1111111111111111111111111111111111111111111111111111111111111111");
}

static void testResultFloat(void) {
    TEST_Result(Float, 10, "10");
    TEST_Result(Float, -10, "-10");
    TEST_Result(Float, 127, "127");
    TEST_Result(Float, -128, "-128");
    TEST_Result(Float, 32767, "32767");
    TEST_Result(Float, -32768, "-32768");
    TEST_Result(Float, 2147483647, "2.14748e+09");
    TEST_Result(Float, -2147483648, "-2.14748e+09");
    TEST_Result(Float, 9223372036854775807LL, "9.22337e+18");
    TEST_Result(Float, -9223372036854775807LL, "-9.22337e+18");

    TEST_Result(Float, 1.256e-17, "1.256e-17");
    TEST_Result(Float, -1.256e-17, "-1.256e-17");
}

static void testResultDouble(void) {
    TEST_Result(Double, 10, "10");
    TEST_Result(Double, -10, "-10");
    TEST_Result(Double, 127, "127");
    TEST_Result(Double, -128, "-128");
    TEST_Result(Double, 32767, "32767");
    TEST_Result(Double, -32768, "-32768");
    TEST_Result(Double, 2147483647, "2147483647");
    TEST_Result(Double, -2147483648, "-2147483648");
    TEST_Result(Double, 9223372036854775807LL, "9.22337203685478e+18");
    TEST_Result(Double, -9223372036854775807LL, "-9.22337203685478e+18");

    TEST_Result(Double, 1.256e-17, "1.256e-17");
    TEST_Result(Double, -1.256e-17, "-1.256e-17");
}

static void testResultBool(void) {
    TEST_Result(Bool, TRUE, "1");
    TEST_Result(Bool, FALSE, "0");
    TEST_Result(Bool, 1000, "1");
}

static void testResultMnemonic(void) {
    TEST_Result(Mnemonic, "a", "a");
    TEST_Result(Mnemonic, "abcd", "abcd");
    TEST_Result(Mnemonic, "abcd123", "abcd123");
}

static void testResultText(void) {
    TEST_Result(Text, "a", "\"a\"");
    TEST_Result(Text, "abcd", "\"abcd\"");
    TEST_Result(Text, "abcd123", "\"abcd123\"");
    TEST_Result(Text, "abcd\"123", "\"abcd\"\"123\"");
    TEST_Result(Text, "abcd\"", "\"abcd\"\"\"");
}

static void testResultArbitraryBlock(void) {
#define SCPI_ResultArbitraryBlockString(c, s) SCPI_ResultArbitraryBlock((c), (s), strlen(s))

    TEST_Result(ArbitraryBlockString, "a", "#11a");
    TEST_Result(ArbitraryBlockString, "a\"", "#12a\"");
    TEST_Result(ArbitraryBlockString, "a\r\n", "#13a\r\n");
    TEST_Result(ArbitraryBlockString, "X1234567890", "#211X1234567890");
    TEST_Result(ArbitraryBlockString, "X1234567890\x80x", "#213X1234567890\x80x");
}

int main() {
    unsigned int result;
    CU_pSuite pSuite = NULL;
@@ -845,6 +1042,20 @@
            || (NULL == CU_add_test(pSuite, "Numeric list", testNumericList))
            || (NULL == CU_add_test(pSuite, "Channel list", testChannelList))
            || (NULL == CU_add_test(pSuite, "SCPI_ParamNumber", testParamNumber))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultInt8", testResultInt8))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultUInt8", testResultUInt8))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultInt16", testResultInt16))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultUInt16", testResultUInt16))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultInt32", testResultInt32))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultUInt32", testResultUInt32))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultInt64", testResultInt64))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultUInt64", testResultUInt64))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultFloat", testResultFloat))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultDouble", testResultDouble))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultBool", testResultBool))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultMnemonic", testResultMnemonic))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultText", testResultText))
            || (NULL == CU_add_test(pSuite, "SCPI_ResultArbitraryBlock", testResultArbitraryBlock))
            ) {
        CU_cleanup_registry();
        return CU_get_error();