From 139d1e959364eccb361f7363815d386274bad8f0 Mon Sep 17 00:00:00 2001
From: Jan Breuer <jan.breuer@jaybee.cz>
Date: 周五, 13 11月 2015 08:25:23 +0800
Subject: [PATCH] Add SCPI_ResultXYZ unit tests for basic types
---
libscpi/test/test_scpi_utils.c | 610 ++++++++++++++++++++++++++++++++++---------------------
1 files changed, 377 insertions(+), 233 deletions(-)
diff --git a/libscpi/test/test_scpi_utils.c b/libscpi/test/test_scpi_utils.c
index 43f5515..98a7305 100644
--- a/libscpi/test/test_scpi_utils.c
+++ b/libscpi/test/test_scpi_utils.c
@@ -4,7 +4,7 @@
* Copyright (c) 2012 Jan Breuer
*
* All Rights Reserved
- *
+ *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
@@ -13,7 +13,7 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- *
+ *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -70,245 +70,338 @@
}
static void test_Int32ToStr() {
- const size_t max=32+1;
+ const size_t max = 32 + 1;
int32_t val[] = {0, 1, -1, INT32_MIN, INT32_MAX, 0x01234567, 0x89abcdef};
+ int N = sizeof (val) / sizeof (int32_t);
+ int i;
char str[max];
char ref[max];
size_t len;
- // test conversion to decimal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_Int32ToStr(val[i], str, max, 10);
+ // test signed conversion to decimal numbers
+ for (i = 0; i < N; i++) {
+ 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);
- snprintf(ref, max, "%"PRIX32, val[i]);
+ int16_t val16[] = {0, 1, -1, INT16_MIN, INT16_MAX, 0x0123, 0x4567, 0x89ab, 0xcdef};
+ int N16 = sizeof (val16) / sizeof (int16_t);
+ // test signed conversion to decimal numbers
+ for (i = 0; i < N16; i++) {
+ len = SCPI_Int32ToStr((int32_t) val16[i], str, max);
+ snprintf(ref, max, "%"PRIi16, val16[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);
- 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);
- CU_ASSERT(len == 1);
- CU_ASSERT_STRING_EQUAL(str, "0");
-
- len = SCPI_Int32ToStr(1, str, max, 2);
- CU_ASSERT(len == 1);
- CU_ASSERT_STRING_EQUAL(str, "1");
-
- len = SCPI_Int32ToStr(-1, str, max, 2);
- CU_ASSERT(len == 32);
- CU_ASSERT_STRING_EQUAL(str, "11111111111111111111111111111111");
-
- len = SCPI_Int32ToStr(0x01234567, str, max, 2);
- CU_ASSERT(len == 25);
- CU_ASSERT_STRING_EQUAL(str, "1001000110100010101100111");
-
- len = SCPI_Int32ToStr(0x89abcdef, str, max, 2);
- CU_ASSERT(len == 32);
- CU_ASSERT_STRING_EQUAL(str, "10001001101010111100110111101111");
}
-static void test_UInt32ToStr() {
- const size_t max=32+1;
+static void test_UInt32ToStrBase() {
+ const size_t max = 32 + 1;
uint32_t val[] = {0, 1, -1, INT32_MIN, INT32_MAX, 0x01234567, 0x89abcdef};
+ int N = sizeof (val) / sizeof (uint32_t);
+ int i;
char str[max];
char ref[max];
size_t len;
// test conversion to decimal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_UInt32ToStr(val[i], str, max, 10);
+ for (i = 0; i < N; i++) {
+ 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);
}
// test conversion to hexadecimal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_UInt32ToStr(val[i], str, max, 16);
+ for (i = 0; i < N; i++) {
+ 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);
}
// test conversion to octal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_UInt32ToStr(val[i], str, max, 8);
+ for (i = 0; i < N; i++) {
+ 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);
- }
-}
-
-static void test_Int64ToStr() {
- const size_t max=64+1;
- int64_t val[] = {0, 1, -1, INT64_MIN, INT64_MAX, 0x0123456789abcdef, 0xfedcba9876543210};
- char str[max];
- char ref[max];
- size_t len;
-
- // test conversion to decimal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_Int64ToStr(val[i], str, max, 10);
- 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);
- 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);
- 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);
+ len = SCPI_UInt32ToStrBase(0, str, max, 2);
CU_ASSERT(len == 1);
CU_ASSERT_STRING_EQUAL(str, "0");
- len = SCPI_Int64ToStr(1, str, max, 2);
+ len = SCPI_UInt32ToStrBase(1, str, max, 2);
CU_ASSERT(len == 1);
CU_ASSERT_STRING_EQUAL(str, "1");
- len = SCPI_Int64ToStr(-1, str, max, 2);
- CU_ASSERT(len == 64);
- CU_ASSERT_STRING_EQUAL(str, "1111111111111111111111111111111111111111111111111111111111111111");
+ len = SCPI_UInt32ToStrBase(-1, str, max, 2);
+ CU_ASSERT(len == 32);
+ CU_ASSERT_STRING_EQUAL(str, "11111111111111111111111111111111");
- len = SCPI_Int64ToStr(0x0123456789abcdef, str, max, 2);
- CU_ASSERT(len == 57);
- CU_ASSERT_STRING_EQUAL(str, "100100011010001010110011110001001101010111100110111101111");
+ len = SCPI_UInt32ToStrBase(0x01234567, str, max, 2);
+ CU_ASSERT(len == 25);
+ CU_ASSERT_STRING_EQUAL(str, "1001000110100010101100111");
- len = SCPI_Int64ToStr(0xfedcba9876543210, str, max, 2);
- CU_ASSERT(len == 64);
- CU_ASSERT_STRING_EQUAL(str, "1111111011011100101110101001100001110110010101000011001000010000");
+ len = SCPI_UInt32ToStrBase(0x89abcdef, str, max, 2);
+ CU_ASSERT(len == 32);
+ CU_ASSERT_STRING_EQUAL(str, "10001001101010111100110111101111");
}
-static void test_UInt64ToStr() {
- const size_t max=64+1;
- uint64_t val[] = {0, 1, -1, INT64_MIN, INT64_MAX, 0x0123456789abcdef, 0xfedcba9876543210};
+static void test_Int64ToStr() {
+ const size_t max = 64 + 1;
+ int64_t val[] = {0, 1, -1, INT64_MIN, INT64_MAX, 0x0123456789abcdef, 0xfedcba9876543210};
+ int N = sizeof (val) / sizeof (int64_t);
+ int i;
char str[max];
char ref[max];
size_t len;
// test conversion to decimal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_UInt64ToStr(val[i], str, max, 10);
+ for (i = 0; i < N; i++) {
+ len = SCPI_Int64ToStr(val[i], str, max);
+ snprintf(ref, max, "%"PRIi64, val[i]);
+ CU_ASSERT(len == strlen(ref));
+ CU_ASSERT_STRING_EQUAL(str, ref);
+ }
+}
+
+static void test_UInt64ToStrBase() {
+ const size_t max = 64 + 1;
+ uint64_t val[] = {0, 1, -1, INT64_MIN, INT64_MAX, 0x0123456789abcdef, 0xfedcba9876543210};
+ int N = sizeof (val) / sizeof (uint64_t);
+ int i;
+ char str[max];
+ char ref[max];
+ size_t len;
+
+ // test conversion to decimal numbers
+ for (i = 0; i < N; i++) {
+ 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);
}
// test conversion to hexadecimal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_UInt64ToStr(val[i], str, max, 16);
+ for (i = 0; i < N; i++) {
+ 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);
}
// test conversion to octal numbers
- for (uintptr_t i=0; i<7; i++) {
- len = SCPI_UInt64ToStr(val[i], str, max, 8);
+ for (i = 0; i < N; i++) {
+ 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_scpi_dtostre() {
+ const size_t strsize = 49 + 1;
+ double val[] = {NAN, INFINITY, -INFINITY, 0,
+ 1, 1.1, 1.01, 1.001, 1.0001, 1.00001, 1.000001, 1.0000001, 1.00000001,
+ 1.000000001, 1.0000000001, 1.00000000001, 1.000000000001,
+ 1.0000000000001, 1e-5, 1.1e-5, 1.01e-5, 1.001e-5, 1.0001e-5, 1.00001e-5,
+ 1.000001e-5, 1.0000001e-5, 1.00000001e-5, 1.000000001e-5,
+ 1.0000000001e-5, 1.00000000001e-5, 1.000000000001e-5,
+ 1.0000000000001e-5, 1, 12, 123, 1234, 12345, 123456, 1234567, 12345678,
+ 123456789, 1234567890, 12345678901, 123456789012, 1234567890123,
+ 12345678901234, 123456789012345, 1234567890123456, 12345678901234567,
+ 123456789012345678, 1234567890123456789, 1234567890123456789e1, 1.1,
+ 10.1, 100.1, 1000.1, 10000.1, 100000.1, 1000000.1, 10000000.1,
+ 100000000.1, 1000000000.1, 0.1234567890123456789,
+ 0.01234567890123456789, 0.001234567890123456789,
+ 0.0001234567890123456789, 0.00001234567890123456789,
+ 0.000001234567890123456789, 0.0000001234567890123456789,
+ 0.00000001234567890123456789, 0.00000000123456789, 0.000000000123456789,
+ 0.0000000000123456789, 0.00000000000123456789, 0.000000000000123456789,
+ 0.0000000000000123456789, 0.00000000000000123456789,
+ 0.000000000000000123456789, 0.0000000000000000123456789,
+ -1e-5, -1.1e-5, -1.01e-5, -1.001e-5, -1.0001e-5, -1.00001e-5,
+ -1.00001e-6, -1.00001e-10, -1.00001e-20, -1.00001e-50, -1.00001e-100,
+ -1.00001e-200, -1.00001e-300, -1.00001e6, -1.00001e10, -1.00001e20,
+ -1.00001e50, -1.00001e100, -1.00001e150, -1.00001e200, -1.00001e300,
+ 1.7976931348623157e308, 2.2250738585072014e-308,
+ -1.7976931348623157e308, -2.2250738585072014e-308};
+ int N = sizeof (val) / sizeof (*val);
+ int i;
+ char str[strsize];
+ char ref[strsize];
+ size_t len;
+
+ for (i = 0; i < N; i++) {
+ len = strlen(SCPI_dtostre(val[i], str, strsize, 15, 0));
+ snprintf(ref, strsize, "%.15lg", val[i]);
+ CU_ASSERT(len == strlen(ref));
+ CU_ASSERT_STRING_EQUAL(str, ref);
+ }
+}
+
+static void test_floatToStr() {
+ const size_t max = 49 + 1;
+ float val[] = {1, -1, 1.1, -1.1, 1e3, 1e30, -1.3e30, -1.3e-30};
+ int N = sizeof (val) / sizeof (float);
+ int i;
+ char str[max];
+ char ref[max];
+ size_t len;
+
+ for (i = 0; i < N; i++) {
+ len = SCPI_FloatToStr(val[i], str, max);
+ snprintf(ref, max, "%g", val[i]);
CU_ASSERT(len == strlen(ref));
CU_ASSERT_STRING_EQUAL(str, ref);
}
}
static void test_doubleToStr() {
- size_t result;
- char str[50];
+ const size_t max = 49 + 1;
+ double val[] = {1, -1, 1.1, -1.1, 1e3, 1e30, -1.3e30, -1.3e-30};
+ int N = sizeof (val) / sizeof (*val);
+ int i;
+ char str[max];
+ char ref[max];
+ size_t len;
-#define TEST_DOUBLE_TO_STR(v, r, s) \
- do { \
- result = SCPI_DoubleToStr(v, str, sizeof(str)); \
- CU_ASSERT_EQUAL(result, r); \
- CU_ASSERT_STRING_EQUAL(str, s); \
- } while(0) \
-
-
- TEST_DOUBLE_TO_STR(1, 1, "1");
- TEST_DOUBLE_TO_STR(-1, 2, "-1");
- TEST_DOUBLE_TO_STR(1.1, 3, "1.1");
- TEST_DOUBLE_TO_STR(-1.1, 4, "-1.1");
- TEST_DOUBLE_TO_STR(1e3, 4, "1000");
- TEST_DOUBLE_TO_STR(1e30, 5, "1e+30");
- TEST_DOUBLE_TO_STR(-1.3e30, 8, "-1.3e+30");
- TEST_DOUBLE_TO_STR(-1.3e-30, 8, "-1.3e-30");
+ for (i = 0; i < N; i++) {
+ len = SCPI_DoubleToStr(val[i], str, max);
+ snprintf(ref, max, "%.15lg", val[i]);
+ CU_ASSERT(len == strlen(ref));
+ CU_ASSERT_STRING_EQUAL(str, ref);
+ }
}
-static void test_strToInt32() {
+static void test_strBaseToInt32() {
size_t result;
int32_t val;
-#define TEST_STR_TO_LONG(s, r, v, b) \
+#define TEST_STR_TO_INT32(s, r, v, b) \
do { \
- result = strToInt32(s, &val, b); \
+ result = strBaseToInt32(s, &val, b); \
CU_ASSERT_EQUAL(val, v); \
CU_ASSERT_EQUAL(result, r); \
} while(0) \
- TEST_STR_TO_LONG("", 0, 0, 10);
- TEST_STR_TO_LONG("1", 1, 1, 10);
- TEST_STR_TO_LONG("10", 2, 10, 10);
- TEST_STR_TO_LONG("-50", 3, -50, 10);
- TEST_STR_TO_LONG("100MHz", 3, 100, 10);
- TEST_STR_TO_LONG("MHz", 0, 0, 10);
- TEST_STR_TO_LONG("1.4", 1, 1, 10);
- TEST_STR_TO_LONG(" 1", 2, 1, 10);
- TEST_STR_TO_LONG(" +100", 5, 100, 10); // space and +
- TEST_STR_TO_LONG("FF", 2, 255, 16); // hexadecimal FF
- TEST_STR_TO_LONG("77", 2, 63, 8); // octal 77
- TEST_STR_TO_LONG("18", 1, 1, 8); // octal 1, 8 is ignored
+ // TODO: extend to corner cases, use scanf as reference
+ TEST_STR_TO_INT32("", 0, 0, 10);
+ TEST_STR_TO_INT32("1", 1, 1, 10);
+ TEST_STR_TO_INT32("10", 2, 10, 10);
+ TEST_STR_TO_INT32("-50", 3, -50, 10);
+ TEST_STR_TO_INT32("100MHz", 3, 100, 10);
+ TEST_STR_TO_INT32("MHz", 0, 0, 10);
+ TEST_STR_TO_INT32("1.4", 1, 1, 10);
+ TEST_STR_TO_INT32(" 1", 2, 1, 10);
+ TEST_STR_TO_INT32(" +100", 5, 100, 10); // space and +
+ TEST_STR_TO_INT32("FF", 2, 255, 16); // hexadecimal FF
+ TEST_STR_TO_INT32("77", 2, 63, 8); // octal 77
+ TEST_STR_TO_INT32("18", 1, 1, 8); // octal 1, 8 is ignored
}
-static void test_strToUInt32() {
+static void test_strBaseToUInt32() {
size_t result;
uint32_t val;
-#define TEST_STR_TO_ULONG(s, r, v, b) \
+#define TEST_STR_TO_UINT32(s, r, v, b) \
do { \
- result = strToUInt32(s, &val, b); \
+ result = strBaseToUInt32(s, &val, b); \
CU_ASSERT_EQUAL(val, v); \
CU_ASSERT_EQUAL(result, r); \
} while(0) \
- TEST_STR_TO_ULONG("", 0, 0, 10);
- TEST_STR_TO_ULONG("1", 1, 1, 10);
- TEST_STR_TO_ULONG("10", 2, 10, 10);
- TEST_STR_TO_ULONG("100MHz", 3, 100, 10);
- TEST_STR_TO_ULONG("MHz", 0, 0, 10);
- TEST_STR_TO_ULONG("1.4", 1, 1, 10);
- TEST_STR_TO_ULONG(" 1", 2, 1, 10);
- TEST_STR_TO_ULONG(" +100", 5, 100, 10); // space and +
- TEST_STR_TO_ULONG("FF", 2, 255, 16); // hexadecimal FF
- TEST_STR_TO_ULONG("77", 2, 63, 8); // octal 77
- TEST_STR_TO_ULONG("18", 1, 1, 8); // octal 1, 8 is ignored
- TEST_STR_TO_ULONG("FFFFFFFF", 8, 0xffffffffu, 16); // octal 1, 8 is ignored
+ // TODO: extend to corner cases, use scanf as reference
+ TEST_STR_TO_UINT32("", 0, 0, 10);
+ TEST_STR_TO_UINT32("1", 1, 1, 10);
+ TEST_STR_TO_UINT32("10", 2, 10, 10);
+ TEST_STR_TO_UINT32("100MHz", 3, 100, 10);
+ TEST_STR_TO_UINT32("MHz", 0, 0, 10);
+ TEST_STR_TO_UINT32("1.4", 1, 1, 10);
+ TEST_STR_TO_UINT32(" 1", 2, 1, 10);
+ TEST_STR_TO_UINT32(" +100", 5, 100, 10); // space and +
+ TEST_STR_TO_UINT32("FF", 2, 255, 16); // hexadecimal FF
+ TEST_STR_TO_UINT32("77", 2, 63, 8); // octal 77
+ TEST_STR_TO_UINT32("18", 1, 1, 8); // octal 1, 8 is ignored
+ TEST_STR_TO_UINT32("FFFFFFFF", 8, 0xffffffffu, 16); // octal 1, 8 is ignored
+}
+
+static void test_strBaseToInt64() {
+ size_t result;
+ int64_t val;
+
+#define TEST_STR_TO_INT64(s, r, v, b) \
+ do { \
+ result = strBaseToInt64(s, &val, b); \
+ CU_ASSERT_EQUAL(val, v); \
+ CU_ASSERT_EQUAL(result, r); \
+ } while(0) \
+
+ // TODO: extend to corner cases, use scanf as reference
+ TEST_STR_TO_INT64("", 0, 0, 10);
+ TEST_STR_TO_INT64("1", 1, 1, 10);
+ TEST_STR_TO_INT64("10", 2, 10, 10);
+ TEST_STR_TO_INT64("-50", 3, -50, 10);
+ TEST_STR_TO_INT64("100MHz", 3, 100, 10);
+ TEST_STR_TO_INT64("MHz", 0, 0, 10);
+ TEST_STR_TO_INT64("1.4", 1, 1, 10);
+ TEST_STR_TO_INT64(" 1", 2, 1, 10);
+ TEST_STR_TO_INT64(" +100", 5, 100, 10); // space and +
+ TEST_STR_TO_INT64("FF", 2, 255, 16); // hexadecimal FF
+ TEST_STR_TO_INT64("77", 2, 63, 8); // octal 77
+ TEST_STR_TO_INT64("18", 1, 1, 8); // octal 1, 8 is ignored
+}
+
+static void test_strBaseToUInt64() {
+ size_t result;
+ uint64_t val;
+
+#define TEST_STR_TO_UINT64(s, r, v, b) \
+ do { \
+ result = strBaseToUInt64(s, &val, b); \
+ CU_ASSERT_EQUAL(val, v); \
+ CU_ASSERT_EQUAL(result, r); \
+ } while(0) \
+
+ // TODO: extend to corner cases, use scanf as reference
+ TEST_STR_TO_UINT64("", 0, 0, 10);
+ TEST_STR_TO_UINT64("1", 1, 1, 10);
+ TEST_STR_TO_UINT64("10", 2, 10, 10);
+ TEST_STR_TO_UINT64("100MHz", 3, 100, 10);
+ TEST_STR_TO_UINT64("MHz", 0, 0, 10);
+ TEST_STR_TO_UINT64("1.4", 1, 1, 10);
+ TEST_STR_TO_UINT64(" 1", 2, 1, 10);
+ TEST_STR_TO_UINT64(" +100", 5, 100, 10); // space and +
+ TEST_STR_TO_UINT64("FF", 2, 255, 16); // hexadecimal FF
+ TEST_STR_TO_UINT64("77", 2, 63, 8); // octal 77
+ TEST_STR_TO_UINT64("18", 1, 1, 8); // octal 1, 8 is ignored
+ TEST_STR_TO_UINT64("FFFFFFFF", 8, 0xffffffffu, 16); // octal 1, 8 is ignored
}
static void test_strToDouble() {
@@ -321,7 +414,7 @@
CU_ASSERT_EQUAL(result, r); \
CU_ASSERT_DOUBLE_EQUAL(v, val, 0.000001); \
} while(0); \
-
+
TEST_STR_TO_DOUBLE("", 0, 0.0);
TEST_STR_TO_DOUBLE(" 1", 2, 1.0);
@@ -410,15 +503,15 @@
scpi_bool_t result;
int32_t values[20];
- #define TEST_MATCH_COMMAND(p, s, r) \
+#define TEST_MATCH_COMMAND(p, s, r) \
do { \
result = matchCommand(p, s, strlen(s), NULL, 0, 0); \
CU_ASSERT_EQUAL(result, r); \
} while(0) \
- #define NOPAREN(...) __VA_ARGS__
+#define NOPAREN(...) __VA_ARGS__
- #define TEST_MATCH_COMMAND2(p, s, r, v) \
+#define TEST_MATCH_COMMAND2(p, s, r, v) \
do { \
int32_t evalues[] = {NOPAREN v}; \
unsigned int cnt = (sizeof(evalues)/4); \
@@ -434,92 +527,94 @@
TEST_MATCH_COMMAND("Ab", "ab", TRUE);
TEST_MATCH_COMMAND("Ab", "aB", TRUE);
TEST_MATCH_COMMAND("AB", "a", FALSE);
- TEST_MATCH_COMMAND("ABc:AACddd", "ab:aac", TRUE);
- TEST_MATCH_COMMAND("ABc:AACddd", "abc:aac", TRUE);
- TEST_MATCH_COMMAND("ABc:AACddd", "abc:aacddd", TRUE);
- TEST_MATCH_COMMAND("ABc:AACddd", "abc:aacdd", FALSE);
- TEST_MATCH_COMMAND("ABc:AACddd", "a:aac", FALSE);
- TEST_MATCH_COMMAND("ABc:AACddd", ":ab:aac", TRUE);
- TEST_MATCH_COMMAND("ABc:AACddd", ":abc:aac", TRUE);
- TEST_MATCH_COMMAND("ABc:AACddd", ":abc:aacddd", TRUE);
- TEST_MATCH_COMMAND("ABc:AACddd", ":abc:aacdd", FALSE);
- TEST_MATCH_COMMAND("ABc:AACddd", ":a:aac", FALSE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", "ab:aac", TRUE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", "abcc:aac", TRUE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", "abcc:aacddd", TRUE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", "abcc:aacdd", FALSE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", "a:aac", FALSE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", ":ab:aac", TRUE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", ":abcc:aac", TRUE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", ":abcc:aacddd", TRUE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", ":abcc:aacdd", FALSE);
+ TEST_MATCH_COMMAND("ABcc:AACddd", ":a:aac", FALSE);
TEST_MATCH_COMMAND("?", "?", TRUE);
TEST_MATCH_COMMAND("A?", "A?", TRUE);
TEST_MATCH_COMMAND("A", "A?", FALSE);
TEST_MATCH_COMMAND("A?", "A", FALSE);
- TEST_MATCH_COMMAND("[:ABc]:AACddd", ":ab:aac", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:AACddd", "aac", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:AACddd", "aac?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:AACddd?", ":ab:aac?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:AACddd?", "aac?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:AACddd?", "aac", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd]:CDe", "ab:bc:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd]:CDe", "ab:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd]:CDe", "ab:cd?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd]:CDe?", "ab:bc:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd]:CDe?", "ab:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd]:CDe?", "ab:cd", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc:BCd[:CDe]", "ab:bc:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc:BCd[:CDe]", "ab:bc", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc:BCd[:CDe]", "ab:bc?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc:BCd[:CDe]?", "ab:bc:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc:BCd[:CDe]?", "ab:bc?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc:BCd[:CDe]?", "ab:bc", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:AACddd", ":ab:aac", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:AACddd", "aac", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:AACddd", "aac?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:AACddd?", ":ab:aac?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:AACddd?", "aac?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:AACddd?", "aac", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd]:CDEFGeeeee", "ab:bcc:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd]:CDEFGeeeee", "ab:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd]:CDEFGeeeee", "ab:cdefg?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd]:CDEFGeeeee?", "ab:bcc:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd]:CDEFGeeeee?", "ab:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd]:CDEFGeeeee?", "ab:cdefg", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc:BCCdddd[:CDEFGeeeee]", "ab:bcc:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc:BCCdddd[:CDEFGeeeee]", "ab:bcc", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc:BCCdddd[:CDEFGeeeee]", "ab:bcc?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc:BCCdddd[:CDEFGeeeee]?", "ab:bcc:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc:BCCdddd[:CDEFGeeeee]?", "ab:bcc?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc:BCCdddd[:CDEFGeeeee]?", "ab:bcc", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]", "ab:bc:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]", "ab:bc", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]", "bc:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]", "ab:bc?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]", "bc:cd?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]?", "ab:bc:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]?", "ab:bc?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]?", "bc:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]?", "ab:bc", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("[:ABc]:BCd[:CDe]?", "bc:cd", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]", "ab:bcc:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]", "ab:bcc", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]", "bcc:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]", "ab:bcc?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]", "bcc:cdefg?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]?", "ab:bcc:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]?", "ab:bcc?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]?", "bcc:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]?", "ab:bcc", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("[:ABcc]:BCCdddd[:CDEFGeeeee]?", "bcc:cdefg", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]", "ab:bc:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]", "ab:bc", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]", "ab:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]", "ab:bc?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]", "ab:cd?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]?", "ab:bc:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]?", "ab:bc?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]?", "ab:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]?", "ab:bc", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe]?", "ab:cd", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]", "ab:bcc:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]", "ab:bcc", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]", "ab:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]", "ab:bcc?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]", "ab:cdefg?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]?", "ab:bcc:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]?", "ab:bcc?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]?", "ab:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]?", "ab:bcc", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee]?", "ab:cdefg", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc:cd:de", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc:de", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:cd:de", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:cd", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:de", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc:cd?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc:de?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:cd:de?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:bc?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:cd?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab:de?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]", "ab?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:cdefg:defffffffff", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:cdefg:deffffffffffffffffffff", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:cdefg:de", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:defffffffff", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:cdefg:defffffffff", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:cdefg", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:defffffffff", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:cdefg?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc:defffffffff?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:cdefg:defffffffff?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:bcc?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:cdefg?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab:defffffffff?", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]", "ab?", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc:cd:de?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc:de?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:cd:de?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:cd?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:de?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab?", TRUE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc:cd", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc:de", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:cd:de", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:bc", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:cd", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab:de", FALSE); // test optional keyword
- TEST_MATCH_COMMAND("ABc[:BCd][:CDe][:DEf]?", "ab", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc:cdefg:defffffffff?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc:defffffffff?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:cdefg:defffffffff?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:cdefg?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:defffffffff?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab?", TRUE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc:cdefg", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc:defffffffff", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:cdefg:defffffffff", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:bcc", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:cdefg", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab:defffffffff", FALSE); // test optional keyword
+ TEST_MATCH_COMMAND("ABcc[:BCCdddd][:CDEFGeeeee][:DEFFFFFFFFFfffffffffff]?", "ab", FALSE); // test optional keyword
TEST_MATCH_COMMAND("*IDN?", "idn", FALSE); // common command
TEST_MATCH_COMMAND("*IDN?", "idn?", FALSE); // common command
TEST_MATCH_COMMAND("*IDN?", "*idn", FALSE); // common command
@@ -528,6 +623,32 @@
TEST_MATCH_COMMAND("*IDN?", ":idn?", FALSE); // common command
TEST_MATCH_COMMAND("*IDN?", ":*idn", FALSE); // common command
TEST_MATCH_COMMAND("*IDN?", ":*idn?", FALSE); // common command
+
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", ":MEAS?", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", "MEAS?", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", ":MEAS:DC?", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", "MEAS:DC?", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", ":MEAS:CURR?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", "MEAS:CURR?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", ":MEAS:SCAL:CURR?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", "MEAS:SCAL:CURR?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", ":MEAS:SCAL:CURR:DC?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", "MEAS:SCAL:CURR:DC?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", ":MEAS:CURR:DC?", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]?", "MEAS:CURR:DC?", TRUE);
+
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", ":MEAS", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", "MEAS", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", ":MEAS:DC", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", "MEAS:DC", FALSE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", ":MEAS:CURR", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", "MEAS:CURR", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", ":MEAS:SCAL:CURR", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", "MEAS:SCAL:CURR", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", ":MEAS:SCAL:CURR:DC", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", "MEAS:SCAL:CURR:DC", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", ":MEAS:CURR:DC", TRUE);
+ TEST_MATCH_COMMAND("MEASure[:SCALar]:CURRent[:DC]", "MEAS:CURR:DC", TRUE);
TEST_MATCH_COMMAND("ABCdef#", "abc", TRUE); // test numeric parameter
TEST_MATCH_COMMAND("ABCdef#", "abc1324", TRUE); // test numeric parameter
@@ -605,6 +726,24 @@
TEST_COMPOSE_COMMAND(":A;C", 2, 3, 1, ":C", TRUE);
}
+static void test_swap(void) {
+#define TEST_SWAP(l, a, b) CU_ASSERT_EQUAL(SCPI_Swap##l(a), b)
+
+ TEST_SWAP(16, 0x0011, 0x1100);
+ TEST_SWAP(16, 0x1234, 0x3412);
+
+ TEST_SWAP(32, 0x00000011, 0x11000000);
+ TEST_SWAP(32, 0x00001234, 0x34120000);
+ TEST_SWAP(32, 0x00AB1234, 0x3412AB00);
+ TEST_SWAP(32, 0xCDAB1234, 0x3412ABCD);
+
+ TEST_SWAP(64, 0x0000000000000011ull, 0x1100000000000000ull);
+ TEST_SWAP(64, 0x0000000000001234ull, 0x3412000000000000ull);
+ TEST_SWAP(64, 0x0000000000AB1234ull, 0x3412AB0000000000ull);
+ TEST_SWAP(64, 0x00000000CDAB1234ull, 0x3412ABCD00000000ull);
+ TEST_SWAP(64, 0x123456789ABCDEF0ull, 0xF0DEBC9A78563412ull);
+}
+
int main() {
unsigned int result;
CU_pSuite pSuite = NULL;
@@ -624,18 +763,23 @@
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, "SCPI_dtostre", test_scpi_dtostre))
+ || (NULL == CU_add_test(pSuite, "floatToStr", test_floatToStr))
|| (NULL == CU_add_test(pSuite, "doubleToStr", test_doubleToStr))
- || (NULL == CU_add_test(pSuite, "strToInt32", test_strToInt32))
- || (NULL == CU_add_test(pSuite, "strToUInt32", test_strToUInt32))
+ || (NULL == CU_add_test(pSuite, "strBaseToInt32", test_strBaseToInt32))
+ || (NULL == CU_add_test(pSuite, "strBaseToUInt32", test_strBaseToUInt32))
+ || (NULL == CU_add_test(pSuite, "strBaseToInt64", test_strBaseToInt64))
+ || (NULL == CU_add_test(pSuite, "strBaseToUInt64", test_strBaseToUInt64))
|| (NULL == CU_add_test(pSuite, "strToDouble", test_strToDouble))
|| (NULL == CU_add_test(pSuite, "compareStr", test_compareStr))
|| (NULL == CU_add_test(pSuite, "compareStrAndNum", test_compareStrAndNum))
|| (NULL == CU_add_test(pSuite, "matchPattern", test_matchPattern))
|| (NULL == CU_add_test(pSuite, "matchCommand", test_matchCommand))
|| (NULL == CU_add_test(pSuite, "composeCompoundCommand", test_composeCompoundCommand))
+ || (NULL == CU_add_test(pSuite, "swap", test_swap))
) {
CU_cleanup_registry();
return CU_get_error();
--
Gitblit v1.9.1