BSON coder unit tests, fixes arising from test failures.

1 files changed, 102 insertions, 44 deletions

diff --git a/apps/px4/tests/test_bson.c b/apps/px4/tests/test_bson.c
index 4ca765e53..d03a8d332 100644
--- a/apps/px4/tests/test_bson.c
+++ b/apps/px4/tests/test_bson.c
@@ -39,34 +39,36 @@
  */
 
 #include <stdio.h>
-#include <systemlib/err.h>
+#include <string.h>
+#include <stdlib.h>
 
+#include <systemlib/err.h>
 #include <systemlib/bson/tinybson.h>
+
 #include "tests.h"
 
-static const bool test_bool = true;
-static const int32_t test_int = 32;
-static const double test_double = 2.5;
-static const char *test_string = "this is a test";
-static const uint8_t test_data[256];
-static const char *test_filename = "/fs/microsd/bson.test";
+static const bool sample_bool = true;
+static const int32_t sample_small_int = 123;
+static const int64_t sample_big_int = (int64_t)INT_MAX + 123LL;
+static const double sample_double = 2.5f;
+static const char *sample_string = "this is a test";
+static const uint8_t sample_data[256];
+//static const char *sample_filename = "/fs/microsd/bson.test";
 
 static int
 encode(bson_encoder_t encoder)
 {
-
-	if (bson_encoder_append_int(encoder, "thisisanillegalbsonpropertynamebecauseitistoolong", 0) == 0)
-		warnx("FAIL: encoder: too-long node name not rejected");
-
-	if (bson_encoder_append_int(encoder, "bool1", test_bool) != 0)
+	if (bson_encoder_append_bool(encoder, "bool1", sample_bool) != 0)
 		warnx("FAIL: encoder: append bool failed");
-	if (bson_encoder_append_int(encoder, "int1", test_int) != 0)
+	if (bson_encoder_append_int(encoder, "int1", sample_small_int) != 0)
 		warnx("FAIL: encoder: append int failed");
-	if (bson_encoder_append_double(encoder, "double1", test_double) != 0)
+	if (bson_encoder_append_int(encoder, "int2", sample_big_int) != 0)
+		warnx("FAIL: encoder: append int failed");
+	if (bson_encoder_append_double(encoder, "double1", sample_double) != 0)
 		warnx("FAIL: encoder: append double failed");
-	if (bson_encoder_append_string(encoder, "string1", test_string) != 0)
+	if (bson_encoder_append_string(encoder, "string1", sample_string) != 0)
 		warnx("FAIL: encoder: append string failed");
-	if (bson_encoder_append_binary(encoder, "data1", test_data) != 0)
+	if (bson_encoder_append_binary(encoder, "data1", BSON_BIN_BINARY, sizeof(sample_data), sample_data) != 0)
 		warnx("FAIL: encoder: append data failed");
 
 	bson_encoder_fini(encoder);
@@ -77,29 +79,70 @@ encode(bson_encoder_t encoder)
 static int
 decode_callback(bson_decoder_t decoder, void *private, bson_node_t node)
 {
+	unsigned len;
+
 	if (!strcmp(node->name, "bool1")) {
-		if (node->b != test_bool)
+		if (node->type != BSON_BOOL) {
+			warnx("FAIL: decoder: bool1 type %d, expected %d", node->type, BSON_BOOL);
+			return 1;
+		}
+		if (node->b != sample_bool) {
 			warnx("FAIL: decoder: bool1 value %s, expected %s", 
 				(node->b ? "true" : "false"),
-				(test_bool ? "true" : "false"));
+				(sample_bool ? "true" : "false"));
+			return 1;
+		}
+		warnx("PASS: decoder: bool1");
 		return 1;
 	}
 	if (!strcmp(node->name, "int1")) {
-		if (node->i != test_int)
-			warnx("FAIL: decoder: int1 value %d, expected %d", node->i, test_int);
+		if (node->type != BSON_INT32) {
+			warnx("FAIL: decoder: int1 type %d, expected %d", node->type, BSON_INT32);
+			return 1;
+		}
+		if (node->i != sample_small_int) {
+			warnx("FAIL: decoder: int1 value %lld, expected %d", node->i, sample_small_int);
+			return 1;
+		}
+		warnx("PASS: decoder: int1");
+		return 1;
+	}
+	if (!strcmp(node->name, "int2")) {
+		if (node->type != BSON_INT64) {
+			warnx("FAIL: decoder: int2 type %d, expected %d", node->type, BSON_INT64);
+			return 1;
+		}
+		if (node->i != sample_big_int) {
+			warnx("FAIL: decoder: int2 value %lld, expected %lld", node->i, sample_big_int);
+			return 1;
+		}
+		warnx("PASS: decoder: int2");
 		return 1;
 	}
 	if (!strcmp(node->name, "double1")) {
-		if (node->d != test_double)
-			warnx("FAIL: decoder: double1 value %f, expected %f", node->d, test_double);
+		if (node->type != BSON_DOUBLE) {
+			warnx("FAIL: decoder: double1 type %d, expected %d", node->type, BSON_DOUBLE);
+			return 1;
+		}
+		if (node->d != sample_double) {
+			warnx("FAIL: decoder: double1 value %f, expected %f", node->d, sample_double);
+			return 1;
+		}
+		warnx("PASS: decoder: double1");
 		return 1;
 	}
 	if (!strcmp(node->name, "string1")) {
-		unsigned len = bson_decoder_data_pending(decoder);
+		if (node->type != BSON_STRING) {
+			warnx("FAIL: decoder: string1 type %d, expected %d", node->type, BSON_STRING);
+			return 1;
+		}
 
-		if (len != (strlen(test_string) + 1)) {
-			warnx("FAIL: decoder: string1 length %d wrong, expected %d", len, strlen(test_string) + 1);
+		len = bson_decoder_data_pending(decoder);
+
+		if (len != strlen(sample_string) + 1) {
+			warnx("FAIL: decoder: string1 length %d wrong, expected %d", len, strlen(sample_string) + 1);
 			return 1;
+		}
 
 		char sbuf[len];
 
@@ -115,20 +158,31 @@ decode_callback(bson_decoder_t decoder, void *private, bson_node_t node)
 			warnx("FAIL: decoder: string1 not 0-terminated");
 			return 1;
 		}
-		if (strcmp(sbuf, test_string)) {
-			warnx("FAIL: decoder: string1 value '%s', expected '%s'", sbuf, test_string);
+		if (strcmp(sbuf, sample_string)) {
+			warnx("FAIL: decoder: string1 value '%s', expected '%s'", sbuf, sample_string);
 			return 1;
 		}
+		warnx("PASS: decoder: string1");
 		return 1;
 	}
 	if (!strcmp(node->name, "data1")) {
-		unsigned len = bson_decoder_data_pending(decoder);
+		if (node->type != BSON_BINDATA) {
+			warnx("FAIL: decoder: data1 type %d, expected %d", node->type, BSON_BINDATA);
+			return 1;
+		}
+
+		len = bson_decoder_data_pending(decoder);
 
-		if (len != sizeof(test_data)) {
-			warnx("FAIL: decoder: data1 length %d, expected %d", len, sizeof(test_data));
+		if (len != sizeof(sample_data)) {
+			warnx("FAIL: decoder: data1 length %d, expected %d", len, sizeof(sample_data));
 			return 1;
 		}
 		
+		if (node->subtype != BSON_BIN_BINARY) {
+			warnx("FAIL: decoder: data1 subtype %d, expected %d", node->subtype, BSON_BIN_BINARY);
+			return 1;
+		}
+
 		uint8_t dbuf[len];
 
 		if (bson_decoder_copy_data(decoder, dbuf)) {
@@ -139,18 +193,20 @@ decode_callback(bson_decoder_t decoder, void *private, bson_node_t node)
 			warnx("FAIL: decoder: data1 copy did not exhaust all data");
 			return 1;
 		}
-		if (memcmp(test_data, dbuf, len)) {
+		if (memcmp(sample_data, dbuf, len)) {
 			warnx("FAIL: decoder: data1 compare fail");
 			return 1;
 		}
+		warnx("PASS: decoder: data1");
 		return 1;
 	}
 
-	warnx("FAIL: decoder: unexpected node name '%s'", node->name);
+	if (node->type != BSON_EOO)
+		warnx("FAIL: decoder: unexpected node name '%s'", node->name);
 	return 1;
 }
 
-static int
+static void
 decode(bson_decoder_t decoder)
 {
 	int result;
@@ -163,24 +219,26 @@ decode(bson_decoder_t decoder)
 int
 test_bson(int argc, char *argv[])
 {
-	bson_encoder_t encoder;
-	bson_decoder_t decoder;
+	struct bson_encoder_s encoder;
+	struct bson_decoder_s decoder;
 	void *buf;
-	int len, fd;
+	int len;
 
 	/* encode data to a memory buffer */
 	if (bson_encoder_init_buf(&encoder, NULL, 0))
-		errx("FAIL: bson_encoder_init_buf");
-	encode(encoder);
-	len = bson_encoder_buf_size(encoder);
+		errx(1, "FAIL: bson_encoder_init_buf");
+	encode(&encoder);
+	len = bson_encoder_buf_size(&encoder);
 	if (len <= 0)
-		errx("FAIL: bson_encoder_buf_len");
-	buf = bson_encoder_buf_data(encoder);
+		errx(1, "FAIL: bson_encoder_buf_len");
+	buf = bson_encoder_buf_data(&encoder);
+	if (buf == NULL)
+		errx(1, "FAIL: bson_encoder_buf_data");
 
 	/* now test-decode it */
-	if (bson_decoder_init_buf(&decoder, buf, len))
-		errx("FAIL: bson_decoder_init_buf");
-	decode(decoder);
+	if (bson_decoder_init_buf(&decoder, buf, len, decode_callback, NULL))
+		errx(1, "FAIL: bson_decoder_init_buf");
+	decode(&decoder);
 	free(buf);
 
 	exit(0);