From 3a0d40729383c42af1cef194abc56182955fb9c9 Mon Sep 17 00:00:00 2001
From: Jan Breuer <jan.breuer@jaybee.cz>
Date: 周日, 24 4月 2016 16:57:16 +0800
Subject: [PATCH] Fix test and examples to work with extended errors
---
examples/common/scpi-def.h | 2
libscpi/src/fifo_private.h | 2
examples/test-parser/main.c | 3
libscpi/src/parser.c | 5
examples/test-tcp/main.c | 3
libscpi/src/error.c | 12 ++
libscpi/src/fifo.c | 8 +
libscpi/test/test_parser.c | 115 +++++++++++++++-------------
examples/test-interactive/main.c | 3
examples/test-tcp-srq/main.c | 3
examples/common/scpi-def.c | 2
libscpi/test/test_fifo.c | 77 ++++++++++--------
12 files changed, 132 insertions(+), 103 deletions(-)
diff --git a/examples/common/scpi-def.c b/examples/common/scpi-def.c
index 809fb1e..d5f71ae 100644
--- a/examples/common/scpi-def.c
+++ b/examples/common/scpi-def.c
@@ -412,6 +412,6 @@
};
char scpi_input_buffer[SCPI_INPUT_BUFFER_LENGTH];
-int16_t scpi_error_queue_data[SCPI_ERROR_QUEUE_SIZE];
+scpi_error_t scpi_error_queue_data[SCPI_ERROR_QUEUE_SIZE];
scpi_t scpi_context;
diff --git a/examples/common/scpi-def.h b/examples/common/scpi-def.h
index 908f80b..f451300 100644
--- a/examples/common/scpi-def.h
+++ b/examples/common/scpi-def.h
@@ -13,7 +13,7 @@
extern const scpi_command_t scpi_commands[];
extern scpi_interface_t scpi_interface;
extern char scpi_input_buffer[];
-extern int16_t scpi_error_queue_data[];
+extern scpi_error_t scpi_error_queue_data[];
extern scpi_t scpi_context;
size_t SCPI_Write(scpi_t * context, const char * data, size_t len);
diff --git a/examples/test-interactive/main.c b/examples/test-interactive/main.c
index c8cb4d1..e6e5763 100644
--- a/examples/test-interactive/main.c
+++ b/examples/test-interactive/main.c
@@ -94,7 +94,8 @@
scpi_units_def,
SCPI_IDN1, SCPI_IDN2, SCPI_IDN3, SCPI_IDN4,
scpi_input_buffer, SCPI_INPUT_BUFFER_LENGTH,
- scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE);
+ scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE,
+ NULL, 0);
//printf("%.*s %s\r\n", 3, "asdadasdasdasdas", "b");
printf("SCPI Interactive demo\r\n");
diff --git a/examples/test-parser/main.c b/examples/test-parser/main.c
index e5badb1..e72b8af 100644
--- a/examples/test-parser/main.c
+++ b/examples/test-parser/main.c
@@ -96,7 +96,8 @@
scpi_units_def,
SCPI_IDN1, SCPI_IDN2, SCPI_IDN3, SCPI_IDN4,
scpi_input_buffer, SCPI_INPUT_BUFFER_LENGTH,
- scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE);
+ scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE,
+ NULL, 0);
#define TEST_SCPI_INPUT(cmd) result = SCPI_Input(&scpi_context, cmd, strlen(cmd))
diff --git a/examples/test-tcp-srq/main.c b/examples/test-tcp-srq/main.c
index 095fdb8..af81109 100644
--- a/examples/test-tcp-srq/main.c
+++ b/examples/test-tcp-srq/main.c
@@ -290,7 +290,8 @@
scpi_units_def,
SCPI_IDN1, SCPI_IDN2, SCPI_IDN3, SCPI_IDN4,
scpi_input_buffer, SCPI_INPUT_BUFFER_LENGTH,
- scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE);
+ scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE,
+ NULL, 0);
scpi_context.user_context = &user_data;
user_data.io_listen = createServer(5025);
diff --git a/examples/test-tcp/main.c b/examples/test-tcp/main.c
index f1971c2..bab7bf2 100644
--- a/examples/test-tcp/main.c
+++ b/examples/test-tcp/main.c
@@ -188,7 +188,8 @@
scpi_units_def,
SCPI_IDN1, SCPI_IDN2, SCPI_IDN3, SCPI_IDN4,
scpi_input_buffer, SCPI_INPUT_BUFFER_LENGTH,
- scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE);
+ scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE,
+ NULL, 0);
listenfd = createServer(5025);
diff --git a/libscpi/src/error.c b/libscpi/src/error.c
index 45f12d5..8913ab8 100644
--- a/libscpi/src/error.c
+++ b/libscpi/src/error.c
@@ -123,9 +123,15 @@
}
static scpi_bool_t SCPI_ErrorAddInternal(scpi_t * context, int16_t err, char * info) {
- if (!fifo_add(&context->error_queue, err, info)) {
- fifo_remove_last(&context->error_queue, NULL);
- fifo_add(&context->error_queue, SCPI_ERROR_QUEUE_OVERFLOW, NULL);
+ scpi_error_t error_value;
+ error_value.error_code = err;
+ error_value.device_dependent_info = info;
+ if (!fifo_add(&context->error_queue, &error_value)) {
+ fifo_remove_last(&context->error_queue, &error_value);
+ // TODO free device_dependent_info
+ error_value.error_code = SCPI_ERROR_QUEUE_OVERFLOW;
+ error_value.device_dependent_info = NULL;
+ fifo_add(&context->error_queue, &error_value);
return FALSE;
}
return TRUE;
diff --git a/libscpi/src/fifo.c b/libscpi/src/fifo.c
index 578c9d2..a97ab7a 100644
--- a/libscpi/src/fifo.c
+++ b/libscpi/src/fifo.c
@@ -48,14 +48,16 @@
* @param info
* @return
*/
-scpi_bool_t fifo_add(scpi_fifo_t * fifo, int16_t err, char * info) {
+scpi_bool_t fifo_add(scpi_fifo_t * fifo, const scpi_error_t * value) {
/* FIFO full? */
if (fifo_is_full(fifo)) {
return FALSE;
}
+ if (!value) {
+ return FALSE;
+ }
- fifo->data[fifo->wr].error_code = err;
- fifo->data[fifo->wr].device_dependent_info = info;
+ fifo->data[fifo->wr] = *value;
fifo->wr = (fifo->wr + 1) % (fifo->size);
fifo->count += 1;
return TRUE;
diff --git a/libscpi/src/fifo_private.h b/libscpi/src/fifo_private.h
index 7440bc2..0bc70fd 100644
--- a/libscpi/src/fifo_private.h
+++ b/libscpi/src/fifo_private.h
@@ -48,7 +48,7 @@
void fifo_clear(scpi_fifo_t * fifo) LOCAL;
scpi_bool_t fifo_is_empty(scpi_fifo_t * fifo) LOCAL;
scpi_bool_t fifo_is_full(scpi_fifo_t * fifo) LOCAL;
- scpi_bool_t fifo_add(scpi_fifo_t * fifo, int16_t err, char * info) LOCAL;
+ scpi_bool_t fifo_add(scpi_fifo_t * fifo, const scpi_error_t * value) LOCAL;
scpi_bool_t fifo_remove(scpi_fifo_t * fifo, scpi_error_t * value) LOCAL;
scpi_bool_t fifo_remove_last(scpi_fifo_t * fifo, scpi_error_t * value) LOCAL;
scpi_bool_t fifo_count(scpi_fifo_t * fifo, int16_t * value) LOCAL;
diff --git a/libscpi/src/parser.c b/libscpi/src/parser.c
index b7534cc..6d7f8a9 100644
--- a/libscpi/src/parser.c
+++ b/libscpi/src/parser.c
@@ -527,8 +527,9 @@
size_t step = 0;
const char * quote;
- char * data[SCPIDEFINE_DESCRIPTION_MAX_PARTS];
+ const char * data[SCPIDEFINE_DESCRIPTION_MAX_PARTS];
size_t len[SCPIDEFINE_DESCRIPTION_MAX_PARTS];
+ size_t i;
data[0] = SCPI_ErrorTranslate(error->error_code);
len[0] = strlen(data[0]);
@@ -546,7 +547,7 @@
result += writeDelimiter(context);
result += writeData(context, "\"", 1);
- for (size_t i = 0; data[i] && outputlimit && (i < SCPIDEFINE_DESCRIPTION_MAX_PARTS); i++) {
+ for (i = 0; data[i] && outputlimit && (i < SCPIDEFINE_DESCRIPTION_MAX_PARTS); i++) {
if (i == 1) {
result += writeSemicolon(context);
outputlimit -= 1;
diff --git a/libscpi/test/test_fifo.c b/libscpi/test/test_fifo.c
index 40c65c5..546e0c8 100644
--- a/libscpi/test/test_fifo.c
+++ b/libscpi/test/test_fifo.c
@@ -25,14 +25,15 @@
static void testFifo() {
scpi_fifo_t fifo;
- int16_t fifo_data[4];
+ scpi_error_t fifo_data[4];
fifo_init(&fifo, fifo_data, 4);
- int16_t value;
+ scpi_error_t value;
+ int16_t count_value;
#define TEST_FIFO_COUNT(n) \
do { \
- fifo_count(&fifo, &value); \
- CU_ASSERT_EQUAL(value, n); \
+ fifo_count(&fifo, &count_value); \
+ CU_ASSERT_EQUAL(count_value, n); \
} while(0) \
@@ -40,95 +41,103 @@
CU_ASSERT_TRUE(fifo_is_empty(&fifo));
CU_ASSERT_FALSE(fifo_is_full(&fifo));
- CU_ASSERT_TRUE(fifo_add(&fifo, 1));
+ value.error_code = 1;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(1);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_FALSE(fifo_is_full(&fifo));
- CU_ASSERT_TRUE(fifo_add(&fifo, 2));
+ value.error_code = 2;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(2);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_FALSE(fifo_is_full(&fifo));
- CU_ASSERT_TRUE(fifo_add(&fifo, 3));
+ value.error_code = 3;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(3);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_FALSE(fifo_is_full(&fifo));
- CU_ASSERT_TRUE(fifo_add(&fifo, 4));
+ value.error_code = 4;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(4);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_TRUE(fifo_is_full(&fifo));
- CU_ASSERT_EQUAL(fifo.data[0], 1);
- CU_ASSERT_EQUAL(fifo.data[1], 2);
- CU_ASSERT_EQUAL(fifo.data[2], 3);
- CU_ASSERT_EQUAL(fifo.data[3], 4);
+ CU_ASSERT_EQUAL(fifo.data[0].error_code, 1);
+ CU_ASSERT_EQUAL(fifo.data[1].error_code, 2);
+ CU_ASSERT_EQUAL(fifo.data[2].error_code, 3);
+ CU_ASSERT_EQUAL(fifo.data[3].error_code, 4);
-
- CU_ASSERT_FALSE(fifo_add(&fifo, 5));
+ value.error_code = 5;
+ CU_ASSERT_FALSE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(4);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_TRUE(fifo_is_full(&fifo));
- CU_ASSERT_EQUAL(fifo.data[0], 1);
- CU_ASSERT_EQUAL(fifo.data[1], 2);
- CU_ASSERT_EQUAL(fifo.data[2], 3);
- CU_ASSERT_EQUAL(fifo.data[3], 4);
+ CU_ASSERT_EQUAL(fifo.data[0].error_code, 1);
+ CU_ASSERT_EQUAL(fifo.data[1].error_code, 2);
+ CU_ASSERT_EQUAL(fifo.data[2].error_code, 3);
+ CU_ASSERT_EQUAL(fifo.data[3].error_code, 4);
CU_ASSERT_TRUE(fifo_remove_last(&fifo, &value));
- CU_ASSERT_EQUAL(value, 4);
+ CU_ASSERT_EQUAL(value.error_code, 4);
TEST_FIFO_COUNT(3);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_FALSE(fifo_is_full(&fifo));
- CU_ASSERT_TRUE(fifo_add(&fifo, 6));
+ value.error_code = 6;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(4);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_TRUE(fifo_is_full(&fifo));
- CU_ASSERT_EQUAL(fifo.data[0], 1);
- CU_ASSERT_EQUAL(fifo.data[1], 2);
- CU_ASSERT_EQUAL(fifo.data[2], 3);
- CU_ASSERT_EQUAL(fifo.data[3], 6);
+ CU_ASSERT_EQUAL(fifo.data[0].error_code, 1);
+ CU_ASSERT_EQUAL(fifo.data[1].error_code, 2);
+ CU_ASSERT_EQUAL(fifo.data[2].error_code, 3);
+ CU_ASSERT_EQUAL(fifo.data[3].error_code, 6);
CU_ASSERT_TRUE(fifo_remove(&fifo, &value));
- CU_ASSERT_EQUAL(value, 1);
+ CU_ASSERT_EQUAL(value.error_code, 1);
TEST_FIFO_COUNT(3);
CU_ASSERT_FALSE(fifo_is_empty(&fifo));
CU_ASSERT_FALSE(fifo_is_full(&fifo));
- CU_ASSERT_TRUE(fifo_add(&fifo, 7));
+ value.error_code = 7;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(4);
CU_ASSERT_TRUE(fifo_remove(&fifo, &value));
- CU_ASSERT_EQUAL(value, 2);
+ CU_ASSERT_EQUAL(value.error_code, 2);
TEST_FIFO_COUNT(3);
CU_ASSERT_TRUE(fifo_remove(&fifo, &value));
- CU_ASSERT_EQUAL(value, 3);
+ CU_ASSERT_EQUAL(value.error_code, 3);
TEST_FIFO_COUNT(2);
- CU_ASSERT_TRUE(fifo_add(&fifo, 10));
+ value.error_code = 10;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(3);
- CU_ASSERT_TRUE(fifo_add(&fifo, 11));
+ value.error_code = 11;
+ CU_ASSERT_TRUE(fifo_add(&fifo, &value));
TEST_FIFO_COUNT(4);
CU_ASSERT_TRUE(fifo_remove(&fifo, &value));
- CU_ASSERT_EQUAL(value, 6);
+ CU_ASSERT_EQUAL(value.error_code, 6);
TEST_FIFO_COUNT(3);
CU_ASSERT_TRUE(fifo_remove(&fifo, &value));
- CU_ASSERT_EQUAL(value, 7);
+ CU_ASSERT_EQUAL(value.error_code, 7);
TEST_FIFO_COUNT(2);
CU_ASSERT_TRUE(fifo_remove_last(&fifo, &value));
- CU_ASSERT_EQUAL(value, 11);
+ CU_ASSERT_EQUAL(value.error_code, 11);
TEST_FIFO_COUNT(1);
CU_ASSERT_TRUE(fifo_remove(&fifo, &value));
- CU_ASSERT_EQUAL(value, 10);
+ CU_ASSERT_EQUAL(value.error_code, 10);
TEST_FIFO_COUNT(0);
CU_ASSERT_FALSE(fifo_remove(&fifo, &value));
diff --git a/libscpi/test/test_parser.c b/libscpi/test/test_parser.c
index 580a721..f08f692 100644
--- a/libscpi/test/test_parser.c
+++ b/libscpi/test/test_parser.c
@@ -184,7 +184,7 @@
static char scpi_input_buffer[SCPI_INPUT_BUFFER_LENGTH];
#define SCPI_ERROR_QUEUE_SIZE 4
-static int16_t scpi_error_queue_data[SCPI_ERROR_QUEUE_SIZE];
+static scpi_error_t scpi_error_queue_data[SCPI_ERROR_QUEUE_SIZE];
static int init_suite(void) {
SCPI_Init(&scpi_context,
@@ -193,7 +193,8 @@
scpi_units_def,
"MA", "IN", NULL, "VER",
scpi_input_buffer, SCPI_INPUT_BUFFER_LENGTH,
- scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE);
+ scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE,
+ NULL, 0);
return 0;
}
@@ -387,7 +388,7 @@
{ \
int32_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -396,12 +397,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamInt32(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value, expected_value); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamInt32(void) {
@@ -426,7 +427,7 @@
{ \
uint32_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -435,12 +436,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamUInt32(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value, expected_value); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamUInt32(void) {
@@ -465,7 +466,7 @@
{ \
int64_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -474,12 +475,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamInt64(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value, expected_value); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamInt64(void) {
@@ -506,7 +507,7 @@
{ \
uint64_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -515,12 +516,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamUInt64(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value, expected_value); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamUInt64(void) {
@@ -548,7 +549,7 @@
{ \
float value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -557,12 +558,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamFloat(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_DOUBLE_EQUAL(value, expected_value, 0.000001); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamFloat(void) {
@@ -584,7 +585,7 @@
{ \
double value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -593,12 +594,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamDouble(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_DOUBLE_EQUAL(value, expected_value, 0.000001); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamDouble(void) {
@@ -621,7 +622,7 @@
const char * value; \
size_t value_len; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -630,12 +631,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamCharacters(&scpi_context, &value, &value_len, mandatory); \
/*printf("%.*s\r\n", (int)value_len, value);*/ \
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_NSTRING_EQUAL(value, expected_value, value_len); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamCharacters(void) {
@@ -653,7 +654,7 @@
char value[100]; \
size_t value_len; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -662,13 +663,13 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamCopyText(&scpi_context, value, sizeof(value), &value_len, mandatory);\
/*printf("%.*s\r\n", (int)value_len, value);*/ \
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_STRING_EQUAL(value, expected_value); \
CU_ASSERT_EQUAL(value_len, expected_len); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamCopyText(void) {
@@ -689,21 +690,21 @@
const char * value; \
size_t value_len; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
scpi_context.param_list.lex_state.buffer = data; \
scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
- result = SCPI_ParamArbitraryBlock(&scpi_context, &value, &value_len, mandatory); \
+ result = SCPI_ParamArbitraryBlock(&scpi_context, &value, &value_len, mandatory); \
/*printf("%.*s\r\n", (int)value_len, value);*/ \
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_NSTRING_EQUAL(value, expected_value, value_len); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamArbitraryBlock(void) {
TEST_ParamArbitraryBlock("#204ABCD", TRUE, "ABCD", TRUE, 0);
@@ -714,21 +715,21 @@
{ \
scpi_bool_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
scpi_context.param_list.lex_state.buffer = data; \
scpi_context.param_list.lex_state.len = strlen(scpi_context.param_list.lex_state.buffer);\
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
- result = SCPI_ParamBool(&scpi_context, &value, mandatory); \
+ result = SCPI_ParamBool(&scpi_context, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value, expected_value); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamBool(void) {
TEST_ParamBool("ON", TRUE, TRUE, TRUE, 0);
@@ -743,7 +744,7 @@
{ \
int32_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -752,12 +753,12 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamChoice(&scpi_context, test_options, &value, mandatory); \
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value, expected_value); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testSCPI_ParamChoice(void) {
scpi_choice_def_t test_options[] = {
@@ -778,7 +779,7 @@
{ \
scpi_bool_t result; \
scpi_expr_result_t result2; \
- int16_t errCode; \
+ scpi_error_t errCode; \
scpi_parameter_t param; \
int32_t val_from, val_to; \
scpi_bool_t val_range; \
@@ -790,7 +791,7 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_Parameter(&scpi_context, ¶m, TRUE); \
result2 = SCPI_ExprNumericListEntryInt(&scpi_context, ¶m, index, &val_range, &val_from, &val_to);\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result2, expected_result); \
if (expected_result == SCPI_EXPR_OK) { \
CU_ASSERT_EQUAL(val_range, expected_range); \
@@ -799,14 +800,14 @@
CU_ASSERT_EQUAL(val_to, expected_to); \
} \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
#define TEST_NumericListDouble(data, index, expected_range, expected_from, expected_to, expected_result, expected_error_code) \
{ \
scpi_bool_t result; \
scpi_expr_result_t result2; \
- int16_t errCode; \
+ scpi_error_t errCode; \
scpi_parameter_t param; \
double val_from, val_to; \
scpi_bool_t val_range; \
@@ -818,7 +819,7 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_Parameter(&scpi_context, ¶m, TRUE); \
result2 = SCPI_ExprNumericListEntryDouble(&scpi_context, ¶m, index, &val_range, &val_from, &val_to);\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result2, expected_result); \
if (expected_result == SCPI_EXPR_OK) { \
CU_ASSERT_EQUAL(val_range, expected_range); \
@@ -827,7 +828,7 @@
CU_ASSERT_DOUBLE_EQUAL(val_to, expected_to, 0.0001); \
} \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testNumericList(void) {
@@ -864,7 +865,7 @@
{ \
scpi_bool_t result; \
scpi_expr_result_t result2; \
- int16_t errCode; \
+ scpi_error_t errCode; \
scpi_parameter_t param; \
int32_t val_from[val_len], val_to[val_len]; \
scpi_bool_t val_range; \
@@ -879,7 +880,7 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_Parameter(&scpi_context, ¶m, TRUE); \
result2 = SCPI_ExprChannelListEntry(&scpi_context, ¶m, index, &val_range, val_from, val_to, val_len, &val_dimensions);\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result2, expected_result); \
if (expected_result == SCPI_EXPR_OK) { \
CU_ASSERT_EQUAL(val_dimensions, expected_dimensions); \
@@ -893,7 +894,7 @@
}} \
} \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testChannelList(void) {
@@ -935,7 +936,7 @@
{ \
scpi_number_t value; \
scpi_bool_t result; \
- int16_t errCode; \
+ scpi_error_t errCode; \
\
SCPI_CoreCls(&scpi_context); \
scpi_context.input_count = 0; \
@@ -944,7 +945,7 @@
scpi_context.param_list.lex_state.pos = scpi_context.param_list.lex_state.buffer; \
result = SCPI_ParamNumber(&scpi_context, scpi_special_numbers_def, &value, mandatory);\
\
- errCode = SCPI_ErrorPop(&scpi_context); \
+ SCPI_ErrorPop(&scpi_context, &errCode); \
CU_ASSERT_EQUAL(result, expected_result); \
if (expected_result) { \
CU_ASSERT_EQUAL(value.special, expected_special); \
@@ -953,7 +954,7 @@
CU_ASSERT_EQUAL(value.unit, expected_unit); \
CU_ASSERT_EQUAL(value.base, expected_base); \
} \
- CU_ASSERT_EQUAL(errCode, expected_error_code); \
+ CU_ASSERT_EQUAL(errCode.error_code, expected_error_code); \
}
static void testParamNumber(void) {
@@ -1282,6 +1283,7 @@
}
static void testErrorQueue(void) {
+ scpi_error_t val;
SCPI_ErrorClear(&scpi_context);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 0);
SCPI_ErrorPush(&scpi_context, -1);
@@ -1297,15 +1299,20 @@
SCPI_ErrorPush(&scpi_context, -6);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 4);
- CU_ASSERT_EQUAL(SCPI_ErrorPop(&scpi_context), -1);
+ SCPI_ErrorPop(&scpi_context, &val);
+ CU_ASSERT_EQUAL(val.error_code, -1);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 3);
- CU_ASSERT_EQUAL(SCPI_ErrorPop(&scpi_context), -2);
+ SCPI_ErrorPop(&scpi_context, &val);
+ CU_ASSERT_EQUAL(val.error_code, -2);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 2);
- CU_ASSERT_EQUAL(SCPI_ErrorPop(&scpi_context), -3);
+ SCPI_ErrorPop(&scpi_context, &val);
+ CU_ASSERT_EQUAL(val.error_code, -3);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 1);
- CU_ASSERT_EQUAL(SCPI_ErrorPop(&scpi_context), SCPI_ERROR_QUEUE_OVERFLOW);
+ SCPI_ErrorPop(&scpi_context, &val);
+ CU_ASSERT_EQUAL(val.error_code, SCPI_ERROR_QUEUE_OVERFLOW);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 0);
- CU_ASSERT_EQUAL(SCPI_ErrorPop(&scpi_context), 0);
+ SCPI_ErrorPop(&scpi_context, &val);
+ CU_ASSERT_EQUAL(val.error_code, 0);
CU_ASSERT_EQUAL(SCPI_ErrorCount(&scpi_context), 0);
SCPI_ErrorClear(&scpi_context);
--
Gitblit v1.9.1