integer parser: all functions handling a sign argument are now static, with...

Iztok Jeras

2015-10-06 7a425ef1806183ac563507740e94b5d0a439dad3

integer parser: all functions handling a sign argument are now static, without the SCPI_ prefix

 libscpi/inc/scpi/parser.h

@@ -51,14 +51,10 @@

    size_t SCPI_ResultCharacters(scpi_t * context, const char * data, size_t len);
#define SCPI_ResultMnemonic(context, data) SCPI_ResultCharacters((context), (data), strlen(data))
    size_t SCPI_ResultInt32Base(scpi_t * context, int32_t val, int8_t base, scpi_bool_t sign);
#define SCPI_ResultIntBase(context, val, base) SCPI_ResultInt32Base ((context), (val), (base), TRUE)
    size_t SCPI_ResultUInt32Base(scpi_t * context, uint32_t val, int8_t base);
    size_t SCPI_ResultInt32(scpi_t * context, int32_t val);
#define SCPI_ResultInt(context, val) SCPI_ResultInt32 ((context), (val))
    size_t SCPI_ResultUInt32(scpi_t * context, uint32_t val);
    size_t SCPI_ResultInt64Base(scpi_t * context, int64_t val, int8_t base, scpi_bool_t sign);
    size_t SCPI_ResultUInt64Base(scpi_t * context, uint64_t val, int8_t base);
    size_t SCPI_ResultInt64(scpi_t * context, int64_t val);
    size_t SCPI_ResultUInt64(scpi_t * context, uint64_t val);
    size_t SCPI_ResultDouble(scpi_t * context, double val);
    size_t SCPI_ResultText(scpi_t * context, const char * data);
    size_t SCPI_ResultArbitraryBlock(scpi_t * context, const char * data, size_t len);
@@ -70,9 +66,7 @@
    scpi_bool_t SCPI_ParamErrorOccurred(scpi_t * context);
    scpi_bool_t SCPI_ParamIsNumber(scpi_parameter_t * parameter, scpi_bool_t suffixAllowed);
    scpi_bool_t SCPI_ParamToInt32(scpi_t * context, scpi_parameter_t * parameter, int32_t * value);
#define SCPI_ParamToInt(context, parameter, value) SCPI_ParamToInt32((context), (parameter), (value))
    scpi_bool_t SCPI_ParamToUInt32(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value);
#define SCPI_ParamToUnsignedInt(context, parameter, value) SCPI_ParamToUInt32((context), (parameter), (value))
    scpi_bool_t SCPI_ParamToInt64(scpi_t * context, scpi_parameter_t * parameter, int64_t * value);
    scpi_bool_t SCPI_ParamToUInt64(scpi_t * context, scpi_parameter_t * parameter, uint64_t * value);
    scpi_bool_t SCPI_ParamToDouble(scpi_t * context, scpi_parameter_t * parameter, double * value);
@@ -81,9 +75,7 @@


    scpi_bool_t SCPI_ParamInt32(scpi_t * context, int32_t * value, scpi_bool_t mandatory);
#define SCPI_ParamInt(context, value, mandatory) SCPI_ParamInt32((context), (value), (mandatory))
    scpi_bool_t SCPI_ParamUInt32(scpi_t * context, uint32_t * value, scpi_bool_t mandatory);
#define SCPI_ParamUnsignedInt(context, value, mandatory) SCPI_ParamUInt32((context), (value), (mandatory))
    scpi_bool_t SCPI_ParamInt64(scpi_t * context, int64_t * value, scpi_bool_t mandatory);
    scpi_bool_t SCPI_ParamUInt64(scpi_t * context, uint64_t * value, scpi_bool_t mandatory);
    scpi_bool_t SCPI_ParamDouble(scpi_t * context, double * value, scpi_bool_t mandatory);
@@ -99,6 +91,15 @@
    scpi_bool_t SCPI_Match(const char * pattern, const char * value, size_t len);
    scpi_bool_t SCPI_CommandNumbers(scpi_t * context, int32_t * numbers, size_t len, int32_t default_value);


    // deprecated finction, should be removed later
#define SCPI_ResultIntBase(context, val, base) SCPI_ResultInt32Base ((context), (val), (base), TRUE)
#define SCPI_ResultInt(context, val) SCPI_ResultInt32 ((context), (val))
#define SCPI_ParamToInt(context, parameter, value) SCPI_ParamToInt32((context), (parameter), (value))
#define SCPI_ParamToUnsignedInt(context, parameter, value) SCPI_ParamToUInt32((context), (parameter), (value))
#define SCPI_ParamInt(context, value, mandatory) SCPI_ParamInt32((context), (value), (mandatory))
#define SCPI_ParamUnsignedInt(context, value, mandatory) SCPI_ParamUInt32((context), (value), (mandatory))

#ifdef    __cplusplus
}
#endif

 libscpi/inc/scpi/utils.h

@@ -43,11 +43,15 @@
extern "C" {
#endif

    size_t SCPI_Int32ToStr(int32_t val, char * str, size_t len, int8_t base, scpi_bool_t sign);
#define SCPI_LongToStr(val, str, len, base) SCPI_Int32ToStr((val), (str), (len), (base), TRUE)
    size_t SCPI_Int64ToStr(int64_t val, char * str, size_t len, int8_t base, scpi_bool_t sign);
    size_t SCPI_UInt32ToStrBase(uint32_t val, char * str, size_t len, int8_t base);
    size_t SCPI_Int32ToStr(int32_t val, char * str, size_t len);
    size_t SCPI_UInt64ToStrBase(uint64_t val, char * str, size_t len, int8_t base);
    size_t SCPI_Int64ToStr(int64_t val, char * str, size_t len);
    size_t SCPI_DoubleToStr(double val, char * str, size_t len);

    // deprecated finction, should be removed later
#define SCPI_LongToStr(val, str, len, base) SCPI_Int32ToStr((val), (str), (len), (base), TRUE)

#ifdef    __cplusplus
}
#endif

 libscpi/src/parser.c

@@ -317,46 +317,6 @@
}

/**
 * Write signed 32 bit integer value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultInt32(scpi_t * context, int32_t val) {
    return SCPI_ResultInt32Base(context, val, 10, TRUE);
}

/**
 * Write unsigned 32 bit integer value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultUInt32(scpi_t * context, uint32_t val) {
    return SCPI_ResultInt32Base(context, val, 10, FALSE);
}

/**
 * Write signed 64 bit integer value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultInt64(scpi_t * context, int64_t val) {
    return SCPI_ResultInt64Base(context, val, 10, TRUE);
}

/**
 * Write unsigned 64 bit integer value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultUInt64(scpi_t * context, uint64_t val) {
    return SCPI_ResultInt64Base(context, val, 10, FALSE);
}

/**
 * Return prefix of nondecimal base
 * @param base
 * @return
@@ -378,13 +338,13 @@
 * @param sign
 * @return
 */
size_t SCPI_ResultInt32Base(scpi_t * context, int32_t val, int8_t base, scpi_bool_t sign) {
static size_t resultUInt32BaseSign(scpi_t * context, uint32_t val, int8_t base, scpi_bool_t sign) {
    char buffer[32+1];
    const char * basePrefix;
    size_t result = 0;
    size_t len;

    len = SCPI_Int32ToStr(val, buffer, sizeof (buffer), base, sign);
    len = UInt32ToStrBaseSign(val, buffer, sizeof (buffer), base, sign);
    basePrefix = getBasePrefix(base);

    result += writeDelimiter(context);
@@ -404,13 +364,13 @@
 * @param sign
 * @return
 */
size_t SCPI_ResultInt64Base(scpi_t * context, int64_t val, int8_t base, scpi_bool_t sign) {
static size_t resultUInt64BaseSign(scpi_t * context, uint64_t val, int8_t base, scpi_bool_t sign) {
    char buffer[64+1];
    const char * basePrefix;
    size_t result = 0;
    size_t len;

    len = SCPI_Int64ToStr(val, buffer, sizeof (buffer), base, sign);
    len = UInt64ToStrBaseSign(val, buffer, sizeof (buffer), base, sign);
    basePrefix = getBasePrefix(base);

    result += writeDelimiter(context);
@@ -420,6 +380,47 @@
    result += writeData(context, buffer, len);
    context->output_count++;
    return result;
}

/**
 * Write signed 32 bit integer value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultInt32(scpi_t * context, int32_t val) {
    return resultUInt32BaseSign(context, val, 10, TRUE);
}

/**
 * Write unsigned 32 bit integer value in specific base to the result
 * Write signed/unsigned 32 bit integer value in specific base to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultUInt32Base(scpi_t * context, uint32_t val, int8_t base) {
    return resultUInt32BaseSign(context, val, base, FALSE);
}

/**
 * Write signed 64 bit integer value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultInt64(scpi_t * context, int64_t val) {
    return resultUInt64BaseSign(context, val, 10, TRUE);
}

/**
 * Write unsigned 64 bit integer value in specific base to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultUInt64Base(scpi_t * context, uint64_t val, int8_t base) {
    return resultUInt64BaseSign(context, val, base, FALSE);
}

/**
@@ -468,7 +469,7 @@
    char block_header[12];
    size_t header_len;
    block_header[0] = '#';
    SCPI_Int32ToStr(len, block_header + 2, 10, 10, FALSE);
    SCPI_UInt32ToStrBase((uint32_t) len, block_header + 2, 10, 10);

    header_len = strlen(block_header + 2);
    block_header[1] = (char)(header_len + '0');
@@ -487,7 +488,7 @@
 * @return
 */
size_t SCPI_ResultBool(scpi_t * context, scpi_bool_t val) {
    return SCPI_ResultInt32Base(context, val ? 1 : 0, 10, FALSE);
    return resultUInt32BaseSign(context, val ? 1 : 0, 10, FALSE);
}

/* parsing parameters */

 libscpi/src/utils.c

@@ -69,7 +69,7 @@
}

/**
 * Converts signed/unsigned 32 bit integer value to string
 * Converts signed/unsigned 32 bit integer value to string in specific base
 * @param val   integer value
 * @param str   converted textual representation
 * @param len   string buffer length
@@ -77,7 +77,7 @@
 * @param sign  
 * @return number of bytes written to str (without '\0')
 */
size_t SCPI_Int32ToStr(int32_t val, char * str, size_t len, int8_t base, scpi_bool_t sign) {
static size_t UInt32ToStrBaseSign(uint32_t val, char * str, size_t len, int8_t base, scpi_bool_t sign) {
    const char digits[] = "0123456789ABCDEF";

#define ADD_CHAR(c) if (pos < len) str[pos++] = (c)
@@ -110,7 +110,7 @@
        }

        // add sign for numbers in base 10
        if (sign && (val < 0) && (base == 10)) {
        if (sign && ((int32_t) val < 0) && (base == 10)) {
            uval = -val;
            ADD_CHAR('-');
        }
@@ -134,7 +134,30 @@
}

/**
 * Converts signed/unsigned 64 bit integer value to string
 * Converts signed 32 bit integer value to string
 * @param val   integer value
 * @param str   converted textual representation
 * @param len   string buffer length
 * @return number of bytes written to str (without '\0')
 */
size_t SCPI_Int32ToStr(int32_t val, char * str, size_t len) {
    UInt32ToStrBaseSign((int32_t) val, str, len, 10, TRUE);
}

/**
 * Converts unsigned 32 bit integer value to string in specific base
 * @param val   integer value
 * @param str   converted textual representation
 * @param len   string buffer length
 * @param base  output base
 * @return number of bytes written to str (without '\0')
 */
size_t SCPI_UInt32ToStrBase(uint32_t val, char * str, size_t len, int8_t base) {
    UInt32ToStrBaseSign(val, str, len, base, TRUE);
}

/**
 * Converts signed/unsigned 64 bit integer value to string in specific base
 * @param val   integer value
 * @param str   converted textual representation
 * @param len   string buffer length
@@ -142,7 +165,7 @@
 * @param sign  
 * @return number of bytes written to str (without '\0')
 */
size_t SCPI_Int64ToStr(int64_t val, char * str, size_t len, int8_t base, scpi_bool_t sign) {
static size_t UInt64ToStrBaseSign(uint64_t val, char * str, size_t len, int8_t base, scpi_bool_t sign) {
    const char digits[] = "0123456789ABCDEF";

#define ADD_CHAR(c) if (pos < len) str[pos++] = (c)
@@ -175,7 +198,7 @@
        }

        // add sign for numbers in base 10
        if (sign && (val < 0) && (base == 10)) {
        if (sign && ((int64_t) val < 0) && (base == 10)) {
            uval = -val;
            ADD_CHAR('-');
        }
@@ -199,6 +222,29 @@
}

/**
 * Converts signed 64 bit integer value to string
 * @param val   integer value
 * @param str   converted textual representation
 * @param len   string buffer length
 * @return number of bytes written to str (without '\0')
 */
size_t SCPI_Int64ToStr(int64_t val, char * str, size_t len) {
    UInt64ToStrBaseSign((int64_t) val, str, len, 10, TRUE);
}

/**
 * Converts signed/unsigned 64 bit integer value to string in specific base
 * @param val   integer value
 * @param str   converted textual representation
 * @param len   string buffer length
 * @param base  output base
 * @return number of bytes written to str (without '\0')
 */
size_t SCPI_UInt64ToStrBase(uint64_t val, char * str, size_t len, int8_t base) {
    UInt64ToStrBaseSign(val, str, len, base, TRUE);
}

/**
 * Converts double value to string
 * @param val   double value
 * @param str   converted textual representation

 libscpi/test/test_scpi_utils.c

@@ -76,53 +76,16 @@
    char ref[max];
    size_t len;

    // test conversion to decimal numbers
    // test signed conversion to decimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int32ToStr(val[i], str, max, 10, TRUE);
        len = SCPI_Int32ToStr(val[i], str, max);
        snprintf(ref, max, "%"PRIi32, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to hexadecimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int32ToStr(val[i], str, max, 16, TRUE);
        snprintf(ref, max, "%"PRIX32, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to octal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int32ToStr(val[i], str, max, 8, TRUE);
        snprintf(ref, max, "%"PRIo32, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to binary numbers
    len = SCPI_Int32ToStr(0, str, max, 2, TRUE);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "0");

    len = SCPI_Int32ToStr(1, str, max, 2, TRUE);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "1");

    len = SCPI_Int32ToStr(-1, str, max, 2, TRUE);
    CU_ASSERT(len == 32);
    CU_ASSERT_STRING_EQUAL(str, "11111111111111111111111111111111");

    len = SCPI_Int32ToStr(0x01234567, str, max, 2, TRUE);
    CU_ASSERT(len == 25);
    CU_ASSERT_STRING_EQUAL(str, "1001000110100010101100111");

    len = SCPI_Int32ToStr(0x89abcdef, str, max, 2, TRUE);
    CU_ASSERT(len == 32);
    CU_ASSERT_STRING_EQUAL(str, "10001001101010111100110111101111");
}

static void test_UInt32ToStr() {
static void test_UInt32ToStrBase() {
    const size_t max=32+1;
    uint32_t val[] = {0, 1, -1, INT32_MIN, INT32_MAX, 0x01234567, 0x89abcdef};
    char str[max];
@@ -131,7 +94,7 @@

    // test conversion to decimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int32ToStr(val[i], str, max, 10, FALSE);
        len = SCPI_UInt32ToStrBase(val[i], str, max, 10);
        snprintf(ref, max, "%"PRIu32, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
@@ -139,7 +102,7 @@

    // test conversion to hexadecimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int32ToStr(val[i], str, max, 16, FALSE);
        len = SCPI_UInt32ToStrBase(val[i], str, max, 16);
        snprintf(ref, max, "%"PRIX32, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
@@ -147,11 +110,32 @@

    // test conversion to octal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int32ToStr(val[i], str, max, 8, FALSE);
        len = SCPI_UInt32ToStrBase(val[i], str, max, 8);
        snprintf(ref, max, "%"PRIo32, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to binary numbers
    len = SCPI_UInt32ToStrBase(0, str, max, 2);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "0");

    len = SCPI_UInt32ToStrBase(1, str, max, 2);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "1");

    len = SCPI_UInt32ToStrBase(-1, str, max, 2);
    CU_ASSERT(len == 32);
    CU_ASSERT_STRING_EQUAL(str, "11111111111111111111111111111111");

    len = SCPI_UInt32ToStrBase(0x01234567, str, max, 2);
    CU_ASSERT(len == 25);
    CU_ASSERT_STRING_EQUAL(str, "1001000110100010101100111");

    len = SCPI_UInt32ToStrBase(0x89abcdef, str, max, 2);
    CU_ASSERT(len == 32);
    CU_ASSERT_STRING_EQUAL(str, "10001001101010111100110111101111");
}

static void test_Int64ToStr() {
@@ -163,51 +147,14 @@

    // test conversion to decimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int64ToStr(val[i], str, max, 10, TRUE);
        len = SCPI_Int64ToStr(val[i], str, max);
        snprintf(ref, max, "%"PRIi64, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to hexadecimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int64ToStr(val[i], str, max, 16, TRUE);
        snprintf(ref, max, "%"PRIX64, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to octal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int64ToStr(val[i], str, max, 8, TRUE);
        snprintf(ref, max, "%"PRIo64, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to binary numbers
    len = SCPI_Int64ToStr(0, str, max, 2, TRUE);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "0");

    len = SCPI_Int64ToStr(1, str, max, 2, TRUE);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "1");

    len = SCPI_Int64ToStr(-1, str, max, 2, TRUE);
    CU_ASSERT(len == 64);
    CU_ASSERT_STRING_EQUAL(str, "1111111111111111111111111111111111111111111111111111111111111111");

    len = SCPI_Int64ToStr(0x0123456789abcdef, str, max, 2, TRUE);
    CU_ASSERT(len == 57);
    CU_ASSERT_STRING_EQUAL(str, "100100011010001010110011110001001101010111100110111101111");

    len = SCPI_Int64ToStr(0xfedcba9876543210, str, max, 2, TRUE);
    CU_ASSERT(len == 64);
    CU_ASSERT_STRING_EQUAL(str, "1111111011011100101110101001100001110110010101000011001000010000");
}

static void test_UInt64ToStr() {
static void test_UInt64ToStrBase() {
    const size_t max=64+1;
    uint64_t val[] = {0, 1, -1, INT64_MIN, INT64_MAX, 0x0123456789abcdef, 0xfedcba9876543210};
    char str[max];
@@ -216,7 +163,7 @@

    // test conversion to decimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int64ToStr(val[i], str, max, 10, FALSE);
        len = SCPI_UInt64ToStrBase(val[i], str, max, 10);
        snprintf(ref, max, "%"PRIu64, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
@@ -224,7 +171,7 @@

    // test conversion to hexadecimal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int64ToStr(val[i], str, max, 16, FALSE);
        len = SCPI_UInt64ToStrBase(val[i], str, max, 16);
        snprintf(ref, max, "%"PRIX64, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
@@ -232,11 +179,32 @@

    // test conversion to octal numbers
    for (uintptr_t i=0; i<7; i++) {
        len = SCPI_Int64ToStr(val[i], str, max, 8, FALSE);
        len = SCPI_UInt64ToStrBase(val[i], str, max, 8);
        snprintf(ref, max, "%"PRIo64, val[i]);
        CU_ASSERT(len == strlen(ref));
        CU_ASSERT_STRING_EQUAL(str, ref);
    }

    // test conversion to binary numbers
    len = SCPI_UInt64ToStrBase(0, str, max, 2);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "0");

    len = SCPI_UInt64ToStrBase(1, str, max, 2);
    CU_ASSERT(len == 1);
    CU_ASSERT_STRING_EQUAL(str, "1");

    len = SCPI_UInt64ToStrBase(-1, str, max, 2);
    CU_ASSERT(len == 64);
    CU_ASSERT_STRING_EQUAL(str, "1111111111111111111111111111111111111111111111111111111111111111");

    len = SCPI_UInt64ToStrBase(0x0123456789abcdef, str, max, 2);
    CU_ASSERT(len == 57);
    CU_ASSERT_STRING_EQUAL(str, "100100011010001010110011110001001101010111100110111101111");

    len = SCPI_UInt64ToStrBase(0xfedcba9876543210, str, max, 2);
    CU_ASSERT(len == 64);
    CU_ASSERT_STRING_EQUAL(str, "1111111011011100101110101001100001110110010101000011001000010000");
}

static void test_doubleToStr() {
@@ -624,9 +592,9 @@
    if (0
            || (NULL == CU_add_test(pSuite, "strnpbrk", test_strnpbrk))
            || (NULL == CU_add_test(pSuite, "Int32ToStr", test_Int32ToStr))
            || (NULL == CU_add_test(pSuite, "UInt32ToStr", test_UInt32ToStr))
            || (NULL == CU_add_test(pSuite, "UInt32ToStrBase", test_UInt32ToStrBase))
            || (NULL == CU_add_test(pSuite, "Int64ToStr", test_Int64ToStr))
            || (NULL == CU_add_test(pSuite, "UInt64ToStr", test_UInt64ToStr))
            || (NULL == CU_add_test(pSuite, "UInt64ToStrBase", test_UInt64ToStrBase))
            || (NULL == CU_add_test(pSuite, "doubleToStr", test_doubleToStr))
            || (NULL == CU_add_test(pSuite, "strToInt32", test_strToInt32))
            || (NULL == CU_add_test(pSuite, "strToUInt32", test_strToUInt32))