From 7a425ef1806183ac563507740e94b5d0a439dad3 Mon Sep 17 00:00:00 2001
From: Iztok Jeras <iztok.jeras@redpitaya.com>
Date: ćšć, 08 10æ 2015 03:00:34 +0800
Subject: [PATCH] integer parser: all functions handling a sign argument are now static, without the SCPI_ prefix
---
libscpi/src/parser.c | 93 +++++++-------
libscpi/test/test_scpi_utils.c | 142 +++++++++--------------
libscpi/inc/scpi/parser.h | 21 +-
libscpi/inc/scpi/utils.h | 10 +
libscpi/src/utils.c | 58 ++++++++-
5 files changed, 172 insertions(+), 152 deletions(-)
diff --git a/libscpi/inc/scpi/parser.h b/libscpi/inc/scpi/parser.h
index f7f2716..cfa944b 100644
--- a/libscpi/inc/scpi/parser.h
+++ b/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
diff --git a/libscpi/inc/scpi/utils.h b/libscpi/inc/scpi/utils.h
index 6822650..66e5cda 100644
--- a/libscpi/inc/scpi/utils.h
+++ b/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
diff --git a/libscpi/src/parser.c b/libscpi/src/parser.c
index 5e475a9..ffd8de1 100644
--- a/libscpi/src/parser.c
+++ b/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 */
diff --git a/libscpi/src/utils.c b/libscpi/src/utils.c
index 711782d..62de94a 100644
--- a/libscpi/src/utils.c
+++ b/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
diff --git a/libscpi/test/test_scpi_utils.c b/libscpi/test/test_scpi_utils.c
index 5951520..84b382b 100644
--- a/libscpi/test/test_scpi_utils.c
+++ b/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))
--
Gitblit v1.9.1