test/cbor_test.c - third_party/github/jimsch/cn-cbor - Git at Google

 /*
  * Copyright (c) 2015 SPUDlib authors.  See LICENSE file.
  */

 #ifdef _MSC_VER
 #define _CRT_SECURE_NO_WARNINGS
 #define _CRTDBG_MAP_ALLOC
 #include <crtdbg.h>
 #endif

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
 #ifdef _MSC_VER
 #include "winsock2.h"
 #endif

 #include "cn-cbor/cn-cbor.h"
 #include "context.h"

 #define CTEST_MAIN
 #include "ctest.h"

 #ifdef USE_CBOR_CONTEXT
 cn_cbor_context *context;
 #endif

 int main(int argc, const char *argv[])
 {
 #ifdef USE_CBOR_CONTEXT
 	context = CreateContext(-1);
 #endif

 	int i = ctest_main(argc, argv);
 #ifdef USE_CBOR_CONTEXT
 	if (IsContextEmpty(context) > 0) {
 		i += 1;
 		printf("MEMORY CONTEXT NOT EMPTY");
 	}
 #endif
 	return i;
 }

 #ifdef USE_CBOR_CONTEXT
 #define CONTEXT_NULL , context
 #define CONTEXT_NULL_COMMA context,
 #else
 #define CONTEXT_NULL
 #define CONTEXT_NULL_COMMA
 #endif

 typedef struct _buffer {
 	size_t sz;
 	unsigned char *ptr;
 } buffer;

 static bool parse_hex(char *inp, buffer *b)
 {
 	size_t len = strlen(inp);
 	size_t i = 0;
 	if (len % 2 != 0) {
 		b->sz = -1;
 		b->ptr = NULL;
 		return false;
 	}
 	b->sz = len / 2;
 	b->ptr = malloc(b->sz);
 	for (i = 0; i < b->sz; i++) {
 #ifdef _MSC_VER
 		unsigned short iX;
 		sscanf(inp + (2 * i), "%02hx", &iX);
 		b->ptr[i] = (byte)iX;
 #else
 		sscanf(inp + (2 * i), "%02hhx", &b->ptr[i]);
 #endif
 	}
 	return true;
 }

 CTEST(cbor, error)
 {
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_NO_ERROR], "CN_CBOR_NO_ERROR");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_OUT_OF_DATA], "CN_CBOR_ERR_OUT_OF_DATA");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED], "CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_ODD_SIZE_INDEF_MAP], "CN_CBOR_ERR_ODD_SIZE_INDEF_MAP");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_BREAK_OUTSIDE_INDEF], "CN_CBOR_ERR_BREAK_OUTSIDE_INDEF");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_MT_UNDEF_FOR_INDEF], "CN_CBOR_ERR_MT_UNDEF_FOR_INDEF");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_RESERVED_AI], "CN_CBOR_ERR_RESERVED_AI");
 	ASSERT_STR(
 		cn_cbor_error_str[CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING], "CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_INVALID_PARAMETER], "CN_CBOR_ERR_INVALID_PARAMETER");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_OUT_OF_MEMORY], "CN_CBOR_ERR_OUT_OF_MEMORY");
 	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_FLOAT_NOT_SUPPORTED], "CN_CBOR_ERR_FLOAT_NOT_SUPPORTED");
 }

 CTEST(cbor, parse)
 {
 	cn_cbor_errback err;
 	char *tests[] = {
 		"00",				   // 0
 		"01",				   // 1
 		"17",				   // 23
 		"1818",				   // 24
 		"190100",			   // 256
 		"1a00010000",		   // 65536
 		"1b0000000100000000",  // 4294967296
 		"20",				   // -1
 		"37",				   // -24
 		"3818",				   // -25
 		"390100",			   // -257
 		"3a00010000",		   // -65537
 		"3b0000000100000000",  // -4294967297
 		"4161",				   // h"a"
 		"6161",				   // "a"
 		"80",				   // []
 		"8100",				   // [0]
 		"820102",			   // [1,2]
 		"818100",			   // [[0]]
 		"a1616100",			   // {"a":0}
 		"d8184100",			   // tag
 		"f4",				   // false
 		"f5",				   // true
 		"f6",				   // null
 		"f7",				   // undefined
 		"f8ff",				   // simple(255)
 #ifndef CBOR_NO_FLOAT
 		"f93c00",				   // 1.0
 		"f9bc00",				   // -1.0
 		"f903ff",				   // 6.097555160522461e-05
 		"f90400",				   // 6.103515625e-05
 		"f907ff",				   // 0.00012201070785522461
 		"f90800",				   // 0.0001220703125
 		"fa47800000",			   // 65536.0
 		"fb3ff199999999999a",	   // 1.1
 		"f97e00",				   // NaN
 #endif							   /* CBOR_NO_FLOAT */
 		"5f42010243030405ff",	   // (_ h'0102', h'030405')
 		"7f61616161ff",			   // (_ "a", "a")
 		"9fff",					   // [_ ]
 		"9f9f9fffffff",			   // [_ [_ [_ ]]]
 		"9f009f00ff00ff",		   // [_ 0, [_ 0], 0]
 		"bf61610161629f0203ffff",  // {_ "a": 1, "b": [_ 2, 3]}
 	};
 	cn_cbor *cb;
 	buffer b;
 	size_t i;
 	unsigned char encoded[1024];
 	ssize_t enc_sz;
 	ssize_t enc_sz2;

 	for (i = 0; i < sizeof(tests) / sizeof(char *); i++) {
 		ASSERT_TRUE(parse_hex(tests[i], &b));
 		err.err = CN_CBOR_NO_ERROR;
 		cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 		// CTEST_LOG("%s: %s", tests[i], cn_cbor_error_str[err.err]);
 		ASSERT_EQUAL(err.err, CN_CBOR_NO_ERROR);
 		ASSERT_NOT_NULL(cb);

 		enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb);
 		enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb);
 		ASSERT_EQUAL(enc_sz, enc_sz2);
 		ASSERT_DATA(b.ptr, b.sz, encoded, enc_sz);
 		free(b.ptr);
 		cn_cbor_free(cb CONTEXT_NULL);
 	}
 }

 CTEST(cbor, parse_normalize)
 {
 	cn_cbor_errback err;
 	char *basic_tests[] = {
 		"00",
 		"00",  // 0
 		"1800",
 		"00",
 		"1818",
 		"1818",
 		"190000",
 		"00",
 		"190018",
 		"1818",
 		"1a00000000",
 		"00",
 		"1b0000000000000000",
 		"00",
 		"20",
 		"20",  // -1
 		"3800",
 		"20",
 		"c600",
 		"c600",	 // 6(0) (undefined tag)
 		"d80600",
 		"c600",
 		"d9000600",
 		"c600",
 	};
 	char *float_tests[] = {
 		"fb3ff0000000000000", "f93c00",		 // 1.0
 		"fbbff0000000000000", "f9bc00",		 // -1.0
 		"fb40f86a0000000000", "fa47c35000",	 // 100000.0
 		"fb7ff8000000000000", "f97e00",		 // NaN
 		"fb3e70000000000000", "f90001",		 // 5.960464477539063e-08
 		"fb3e78000000000000", "fa33c00000",	 //  8.940696716308594e-08
 		"fb3e80000000000000", "f90002",		 // 1.1920928955078125e-07
 	};
 	cn_cbor *cb;
 	buffer b, b2;
 	size_t i;
 	unsigned char encoded[1024];
 	ssize_t enc_sz;
 	ssize_t enc_sz2;

 	for (i = 0; i < sizeof(basic_tests) / sizeof(char *); i += 2) {
 		ASSERT_TRUE(parse_hex(basic_tests[i], &b));
 		ASSERT_TRUE(parse_hex(basic_tests[i + 1], &b2));
 		err.err = CN_CBOR_NO_ERROR;
 		cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 		CTEST_LOG("%s: %s", basic_tests[i], cn_cbor_error_str[err.err]);
 		ASSERT_EQUAL(err.err, CN_CBOR_NO_ERROR);
 		ASSERT_NOT_NULL(cb);

 		enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb);
 		enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb);
 		ASSERT_EQUAL(enc_sz, enc_sz2);
 		ASSERT_DATA(b2.ptr, b2.sz, encoded, enc_sz);
 		free(b.ptr);
 		free(b2.ptr);
 		cn_cbor_free(cb CONTEXT_NULL);
 	}

 	for (i = 0; i < sizeof(float_tests) / sizeof(char *); i += 2) {
 		ASSERT_TRUE(parse_hex(float_tests[i], &b));
 		ASSERT_TRUE(parse_hex(float_tests[i + 1], &b2));
 		err.err = CN_CBOR_NO_ERROR;
 		cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 		CTEST_LOG("%s: %s", float_tests[i], cn_cbor_error_str[err.err]);
 #ifndef CBOR_NO_FLOAT
 		ASSERT_EQUAL(err.err, CN_CBOR_NO_ERROR);
 		ASSERT_NOT_NULL(cb);
 #else  /* CBOR_NO_FLOAT */
 		ASSERT_EQUAL(err.err, CN_CBOR_ERR_FLOAT_NOT_SUPPORTED);
 		ASSERT_NULL(cb);
 #endif /* CBOR_NO_FLOAT */

 		/* enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb); */
 		/* enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb); */
 		/* ASSERT_EQUAL(enc_sz, enc_sz2); */
 		/* ASSERT_DATA(b2.ptr, b2.sz, encoded, enc_sz); */
 		free(b.ptr);
 		free(b2.ptr);
 		cn_cbor_free(cb CONTEXT_NULL);
 	}
 }

 typedef struct _cbor_failure {
 	char *hex;
 	cn_cbor_error err;
 } cbor_failure;

 CTEST(cbor, fail)
 {
 	cn_cbor_errback err;
 	cbor_failure tests[] = {
 		{"81", CN_CBOR_ERR_OUT_OF_DATA},
 		{"0000", CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED},
 		{"bf00ff", CN_CBOR_ERR_ODD_SIZE_INDEF_MAP},
 		{"ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"1f", CN_CBOR_ERR_MT_UNDEF_FOR_INDEF},
 		{"1c", CN_CBOR_ERR_RESERVED_AI},
 		{"7f4100", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 	};
 	cn_cbor *cb;
 	buffer b;
 	size_t i;
 	uint8_t buf[10];
 	cn_cbor inv = {CN_CBOR_INVALID, 0, {0}, 0, NULL, NULL, NULL, NULL};

 	ASSERT_EQUAL(-1, cn_cbor_encoder_write(buf, 0, sizeof(buf), &inv));

 	for (i = 0; i < sizeof(tests) / sizeof(cbor_failure); i++) {
 		ASSERT_TRUE(parse_hex(tests[i].hex, &b));
 		cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 		ASSERT_NULL(cb);
 		ASSERT_EQUAL(err.err, tests[i].err);

 		free(b.ptr);
 		cn_cbor_free(cb CONTEXT_NULL);
 	}
 }

 // Decoder loses float size information
 CTEST(cbor, float)
 {
 #ifndef CBOR_NO_FLOAT
 	cn_cbor_errback err;
 	char *tests[] = {
 		"f90001",	   // 5.960464477539063e-08
 		"f9c400",	   // -4.0
 		"fa47c35000",  // 100000.0
 		"f97e00",	   // Half NaN, half beast
 		"f9fc00",	   // -Inf
 		"f97c00",	   // Inf
 	};
 	cn_cbor *cb;
 	buffer b;
 	size_t i;
 	unsigned char encoded[1024];
 	ssize_t enc_sz;
 	ssize_t enc_sz2;

 	for (i = 0; i < sizeof(tests) / sizeof(char *); i++) {
 		ASSERT_TRUE(parse_hex(tests[i], &b));
 		cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 		ASSERT_NOT_NULL(cb);

 		enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb);
 		enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb);
 		ASSERT_EQUAL(enc_sz, enc_sz2);
 		ASSERT_DATA(b.ptr, b.sz, encoded, enc_sz);

 		free(b.ptr);
 		cn_cbor_free(cb CONTEXT_NULL);
 	}
 #endif /* CBOR_NO_FLOAT */
 }

 CTEST(cbor, getset)
 {
 	buffer b;
 	cn_cbor *cb;
 	cn_cbor *val;
 	cn_cbor_errback err;

 	ASSERT_TRUE(parse_hex("a40000436363630262626201616100", &b));
 	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 	ASSERT_NOT_NULL(cb);
 	val = cn_cbor_mapget_string(cb, "a");
 	ASSERT_NOT_NULL(val);
 	val = cn_cbor_mapget_string(cb, "bb");
 	ASSERT_NOT_NULL(val);
 	val = cn_cbor_mapget_string(cb, "ccc");
 	ASSERT_NOT_NULL(val);
 	val = cn_cbor_mapget_string(cb, "b");
 	ASSERT_NULL(val);
 	free(b.ptr);
 	cn_cbor_free(cb CONTEXT_NULL);

 	ASSERT_TRUE(parse_hex("a3616100006161206162", &b));
 	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 	ASSERT_NOT_NULL(cb);
 	val = cn_cbor_mapget_int(cb, 0);
 	ASSERT_NOT_NULL(val);
 	val = cn_cbor_mapget_int(cb, -1);
 	ASSERT_NOT_NULL(val);
 	val = cn_cbor_mapget_int(cb, 1);
 	ASSERT_NULL(val);
 	free(b.ptr);
 	cn_cbor_free(cb CONTEXT_NULL);

 	ASSERT_TRUE(parse_hex("8100", &b));
 	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 	ASSERT_NOT_NULL(cb);
 	val = cn_cbor_index(cb, 0);
 	ASSERT_NOT_NULL(val);
 	val = cn_cbor_index(cb, 1);
 	ASSERT_NULL(val);
 	val = cn_cbor_index(cb, -1);
 	ASSERT_NULL(val);
 	free(b.ptr);
 	cn_cbor_free(cb CONTEXT_NULL);
 }

 CTEST(cbor, create)
 {
 	cn_cbor_errback err;
 	const cn_cbor *val;
 	const char *data = "abc";
 	cn_cbor *cb_map = cn_cbor_map_create(CONTEXT_NULL_COMMA & err);
 	cn_cbor *cb_int;
 	cn_cbor *cb_data;
 #ifndef CBOR_NO_FLOAT
 	cn_cbor *cb_dbl;
 #endif

 	ASSERT_NOT_NULL(cb_map);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);

 	cb_int = cn_cbor_int_create(256 CONTEXT_NULL, &err);
 	ASSERT_NOT_NULL(cb_int);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);

 	cb_data = cn_cbor_data_create((const uint8_t *)data, 4 CONTEXT_NULL, &err);
 	ASSERT_NOT_NULL(cb_data);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);

 #ifndef CBOR_NO_FLOAT
 	cb_dbl = cn_cbor_double_create(3.14159 CONTEXT_NULL, &err);
 	ASSERT_NOT_NULL(cb_dbl);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 #endif

 	cn_cbor_mapput_int(cb_map, 5, cb_int CONTEXT_NULL, &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_TRUE(cb_map->length == 2);

 	cn_cbor_mapput_int(cb_map, -7, cb_data CONTEXT_NULL, &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_TRUE(cb_map->length == 4);

 	cn_cbor_mapput_string(cb_map, "foo", cn_cbor_string_create(data CONTEXT_NULL, &err) CONTEXT_NULL, &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_TRUE(cb_map->length == 6);

 	cn_cbor_map_put(
 		cb_map, cn_cbor_string_create("bar" CONTEXT_NULL, &err), cn_cbor_string_create("qux" CONTEXT_NULL, &err), &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_TRUE(cb_map->length == 8);

 #ifndef CBOR_NO_FLOAT
 	cn_cbor_mapput_int(cb_map, 42, cb_dbl CONTEXT_NULL, &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_TRUE(cb_map->length == 10);
 #endif

 	val = cn_cbor_mapget_int(cb_map, 5);
 	ASSERT_NOT_NULL(val);
 	ASSERT_TRUE(val->v.sint == 256);

 	val = cn_cbor_mapget_int(cb_map, -7);
 	ASSERT_NOT_NULL(val);
 	ASSERT_STR(val->v.str, "abc");

 #ifndef CBOR_NO_FLOAT
 	val = cn_cbor_mapget_int(cb_map, 42);
 	ASSERT_NOT_NULL(val);
 	ASSERT_TRUE(val->v.dbl > 3.14 && val->v.dbl < 3.15);
 #endif

 	cn_cbor_free(cb_map CONTEXT_NULL);
 }

 CTEST(cbor, map_errors)
 {
 	cn_cbor_errback err;
 	cn_cbor *ci;
 	ci = cn_cbor_int_create(65536, CONTEXT_NULL_COMMA & err);
 	cn_cbor_mapput_int(ci, -5, NULL, CONTEXT_NULL_COMMA & err);
 	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
 	cn_cbor_mapput_string(ci, "foo", NULL, CONTEXT_NULL_COMMA & err);
 	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
 	cn_cbor_map_put(ci, NULL, NULL, &err);
 	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
 	cn_cbor_free(ci CONTEXT_NULL);
 }

 CTEST(cbor, array)
 {
 	cn_cbor_errback err;
 	cn_cbor *a = cn_cbor_array_create(CONTEXT_NULL_COMMA & err);
 	ASSERT_NOT_NULL(a);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_EQUAL(a->length, 0);

 	cn_cbor_array_append(a, cn_cbor_int_create(256, CONTEXT_NULL_COMMA & err), &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_EQUAL(a->length, 1);

 	cn_cbor_array_append(a, cn_cbor_string_create("five", CONTEXT_NULL_COMMA & err), &err);
 	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
 	ASSERT_EQUAL(a->length, 2);
 	cn_cbor_free(a CONTEXT_NULL);
 }

 CTEST(cbor, array_errors)
 {
 	cn_cbor_errback err;
 	cn_cbor *ci = cn_cbor_int_create(12, CONTEXT_NULL_COMMA & err);
 	cn_cbor_array_append(NULL, ci, &err);
 	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
 	cn_cbor_array_append(ci, NULL, &err);
 	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
 	cn_cbor_free(ci CONTEXT_NULL);
 }

 CTEST(cbor, create_encode)
 {
 	cn_cbor *map;
 	cn_cbor *cdata;
 	char data[] = "data";
 	unsigned char encoded[1024];
 	ssize_t enc_sz;

 	map = cn_cbor_map_create(CONTEXT_NULL_COMMA NULL);
 	ASSERT_NOT_NULL(map);

 	cdata = cn_cbor_data_create((uint8_t *)data, sizeof(data) - 1, CONTEXT_NULL_COMMA NULL);
 	ASSERT_NOT_NULL(cdata);

 	ASSERT_TRUE(cn_cbor_mapput_int(map, 0, cdata, CONTEXT_NULL_COMMA NULL));
 	enc_sz = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), map);
 	ASSERT_EQUAL(7, enc_sz);
 	enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), map);
 	ASSERT_EQUAL(7, enc_sz);
 	cn_cbor_free(map CONTEXT_NULL);
 }

 CTEST(cbor, fail2)
 {
 	cn_cbor_errback err;
 	cbor_failure tests[] = {
 		//  *  End of input in a head:
 		{"18", CN_CBOR_ERR_OUT_OF_DATA},
 		{"19", CN_CBOR_ERR_OUT_OF_DATA},
 		{"1a", CN_CBOR_ERR_OUT_OF_DATA},
 		{"1b", CN_CBOR_ERR_OUT_OF_DATA},
 		{"1901", CN_CBOR_ERR_OUT_OF_DATA},
 		{"1a0102", CN_CBOR_ERR_OUT_OF_DATA},
 		{"1b01020304050607", CN_CBOR_ERR_OUT_OF_DATA},
 		{"38", CN_CBOR_ERR_OUT_OF_DATA},
 		{"58", CN_CBOR_ERR_OUT_OF_DATA},
 		{"78", CN_CBOR_ERR_OUT_OF_DATA},
 		{"98", CN_CBOR_ERR_OUT_OF_DATA},
 		{"9a01ff00", CN_CBOR_ERR_OUT_OF_DATA},
 		{"b8", CN_CBOR_ERR_OUT_OF_DATA},
 		{"d8", CN_CBOR_ERR_OUT_OF_DATA},
 		{"f8", CN_CBOR_ERR_OUT_OF_DATA},
 		{"f900", CN_CBOR_ERR_OUT_OF_DATA},
 		{"fa0000", CN_CBOR_ERR_OUT_OF_DATA},
 		{"fb000000", CN_CBOR_ERR_OUT_OF_DATA},

 		//   *  Definite length strings with short data:
 		{"41", CN_CBOR_ERR_OUT_OF_DATA},
 		{"61", CN_CBOR_ERR_OUT_OF_DATA},
 		{"5affffffff00", CN_CBOR_ERR_OUT_OF_DATA},
 		{"5bffffffffffffffff010203", CN_CBOR_ERR_OUT_OF_DATA},
 		{"7affffffff00", CN_CBOR_ERR_OUT_OF_DATA},
 		{"7b7fffffffffffffff010203", CN_CBOR_ERR_OUT_OF_DATA},

 		//   *  Definite length maps and arrays not closed with enough items:
 		{"81", CN_CBOR_ERR_OUT_OF_DATA},
 		{"818181818181818181", CN_CBOR_ERR_OUT_OF_DATA},
 		{"8200", CN_CBOR_ERR_OUT_OF_DATA},
 		{"a1", CN_CBOR_ERR_OUT_OF_DATA},
 		{"a20102", CN_CBOR_ERR_OUT_OF_DATA},
 		{"a100", CN_CBOR_ERR_OUT_OF_DATA},
 		{"a2000000", CN_CBOR_ERR_OUT_OF_DATA},

 		//   *  Tag number not followed by tag content:
 		{"c0", CN_CBOR_ERR_OUT_OF_DATA},

 		//   *  Indefinite length strings not closed by a break stop code:
 		{"5f4100", CN_CBOR_ERR_OUT_OF_DATA}, {"7f6100", CN_CBOR_ERR_OUT_OF_DATA},

 		//   *  Indefinite length maps and arrays not closed by a break stop code:
 		{"9f", CN_CBOR_ERR_OUT_OF_DATA}, {"9f0102", CN_CBOR_ERR_OUT_OF_DATA}, {"bf", CN_CBOR_ERR_OUT_OF_DATA},
 		{"bf01020102", CN_CBOR_ERR_OUT_OF_DATA}, {"819f", CN_CBOR_ERR_OUT_OF_DATA}, {"9f8000", CN_CBOR_ERR_OUT_OF_DATA},
 		{"9f9f9f9f9fffffffff", CN_CBOR_ERR_OUT_OF_DATA}, {"9f819f819f9fffffff", CN_CBOR_ERR_OUT_OF_DATA},

 		//   *  Reserved additional information values:
 		{"1c", CN_CBOR_ERR_RESERVED_AI},
 		{"1d", CN_CBOR_ERR_RESERVED_AI},
 		{"1e", CN_CBOR_ERR_RESERVED_AI},
 		{"3c", CN_CBOR_ERR_RESERVED_AI},
 		{"3d", CN_CBOR_ERR_RESERVED_AI},
 		{"3e", CN_CBOR_ERR_RESERVED_AI},
 		{"5c", CN_CBOR_ERR_RESERVED_AI},
 		{"5d", CN_CBOR_ERR_RESERVED_AI},
 		{"5e", CN_CBOR_ERR_RESERVED_AI},
 		{"7c", CN_CBOR_ERR_RESERVED_AI},
 		{"7d", CN_CBOR_ERR_RESERVED_AI},
 		{"7e", CN_CBOR_ERR_RESERVED_AI},
 		{"9c", CN_CBOR_ERR_RESERVED_AI},
 		{"9d", CN_CBOR_ERR_RESERVED_AI},
 		{"9e", CN_CBOR_ERR_RESERVED_AI},
 		{"bc", CN_CBOR_ERR_RESERVED_AI},
 		{"bd", CN_CBOR_ERR_RESERVED_AI},
 		{"be", CN_CBOR_ERR_RESERVED_AI},
 		{"dc", CN_CBOR_ERR_RESERVED_AI},
 		{"dd", CN_CBOR_ERR_RESERVED_AI},
 		{"de", CN_CBOR_ERR_RESERVED_AI},
 		{"fc", CN_CBOR_ERR_RESERVED_AI},
 		{"fd", CN_CBOR_ERR_RESERVED_AI},
 		{"fe", CN_CBOR_ERR_RESERVED_AI},

 		//   *  Reserved two-byte encodings of simple types:
 #if 0
 		{"f800", CN_CBOR_ERR_RESERVED_AI},
 		{"f801", CN_CBOR_ERR_RESERVED_AI},
 		{"f818", CN_CBOR_ERR_RESERVED_AI},
 		{"f81f", CN_CBOR_ERR_RESERVED_AI},
 #endif

 		//   *  Indefinite length string chunks not of the correct type:
 		{"5f00ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"5f21ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"5f6100ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"5f80ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"5fa0ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"5fc000ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"5fe0ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"7f4100ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},

 		//   *  Indefinite length string chunks not definite length:
 		{"5f5f4100ffff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
 		{"7f7f6100ffff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},

 		//   *  Break occurring on its own outside of an indefinite length item:
 		{"ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},

 		//   *  Break occurring in a definite length array or map or a tag:
 		{"81ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"8200ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"a1ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"a1ff00", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"a100ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"a20000ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"9f81ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
 		{"9f829f819f9fffffffff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},

 		//   *  Break in indefinite length map would lead to odd number of items (break in a value position):
 		{"bf00ff", CN_CBOR_ERR_ODD_SIZE_INDEF_MAP},
 		{"bf000000ff", CN_CBOR_ERR_ODD_SIZE_INDEF_MAP},

 		//   *  Major type 0, 1, 6 with additional information 31:
 		{"1f", CN_CBOR_ERR_MT_UNDEF_FOR_INDEF},
 		{"3f", CN_CBOR_ERR_MT_UNDEF_FOR_INDEF},
 		{"df", CN_CBOR_ERR_OUT_OF_DATA}
 	};
 	cn_cbor *cb;
 	buffer b;
 	size_t i;
 	uint8_t buf[10];
 	cn_cbor inv = {CN_CBOR_INVALID, 0, {0}, 0, NULL, NULL, NULL, NULL};

 	ASSERT_EQUAL(-1, cn_cbor_encoder_write(buf, 0, sizeof(buf), &inv));

 	for (i = 0; i < sizeof(tests) / sizeof(cbor_failure); i++) {
 		ASSERT_TRUE(parse_hex(tests[i].hex, &b));
 		cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
 		// CTEST_LOG("%s: %s %s", tests[i].hex, cn_cbor_error_str[tests[i].err], cn_cbor_error_str[err.err]);
 		ASSERT_NULL(cb);
 		ASSERT_EQUAL(err.err, tests[i].err);

 		free(b.ptr);
 		cn_cbor_free(cb CONTEXT_NULL);
 	}
 }
	/*
	* Copyright (c) 2015 SPUDlib authors. See LICENSE file.
	*/

	#ifdef _MSC_VER
	#define _CRT_SECURE_NO_WARNINGS
	#define _CRTDBG_MAP_ALLOC
	#include <crtdbg.h>
	#endif

	#include <stdlib.h>
	#include <stdint.h>
	#include <stdbool.h>
	#include <stdio.h>
	#include <assert.h>
	#include <string.h>
	#ifdef _MSC_VER
	#include "winsock2.h"
	#endif

	#include "cn-cbor/cn-cbor.h"
	#include "context.h"

	#define CTEST_MAIN
	#include "ctest.h"

	#ifdef USE_CBOR_CONTEXT
	cn_cbor_context *context;
	#endif

	int main(int argc, const char *argv[])
	{
	#ifdef USE_CBOR_CONTEXT
	context = CreateContext(-1);
	#endif

	int i = ctest_main(argc, argv);
	#ifdef USE_CBOR_CONTEXT
	if (IsContextEmpty(context) > 0) {
	i += 1;
	printf("MEMORY CONTEXT NOT EMPTY");
	}
	#endif
	return i;
	}

	#ifdef USE_CBOR_CONTEXT
	#define CONTEXT_NULL , context
	#define CONTEXT_NULL_COMMA context,
	#else
	#define CONTEXT_NULL
	#define CONTEXT_NULL_COMMA
	#endif

	typedef struct _buffer {
	size_t sz;
	unsigned char *ptr;
	} buffer;

	static bool parse_hex(char inp, buffer b)
	{
	size_t len = strlen(inp);
	size_t i = 0;
	if (len % 2 != 0) {
	b->sz = -1;
	b->ptr = NULL;
	return false;
	}
	b->sz = len / 2;
	b->ptr = malloc(b->sz);
	for (i = 0; i < b->sz; i++) {
	#ifdef _MSC_VER
	unsigned short iX;
	sscanf(inp + (2 * i), "%02hx", &iX);
	b->ptr[i] = (byte)iX;
	#else
	sscanf(inp + (2 * i), "%02hhx", &b->ptr[i]);
	#endif
	}
	return true;
	}

	CTEST(cbor, error)
	{
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_NO_ERROR], "CN_CBOR_NO_ERROR");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_OUT_OF_DATA], "CN_CBOR_ERR_OUT_OF_DATA");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED], "CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_ODD_SIZE_INDEF_MAP], "CN_CBOR_ERR_ODD_SIZE_INDEF_MAP");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_BREAK_OUTSIDE_INDEF], "CN_CBOR_ERR_BREAK_OUTSIDE_INDEF");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_MT_UNDEF_FOR_INDEF], "CN_CBOR_ERR_MT_UNDEF_FOR_INDEF");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_RESERVED_AI], "CN_CBOR_ERR_RESERVED_AI");
	ASSERT_STR(
	cn_cbor_error_str[CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING], "CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_INVALID_PARAMETER], "CN_CBOR_ERR_INVALID_PARAMETER");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_OUT_OF_MEMORY], "CN_CBOR_ERR_OUT_OF_MEMORY");
	ASSERT_STR(cn_cbor_error_str[CN_CBOR_ERR_FLOAT_NOT_SUPPORTED], "CN_CBOR_ERR_FLOAT_NOT_SUPPORTED");
	}

	CTEST(cbor, parse)
	{
	cn_cbor_errback err;
	char *tests[] = {
	"00", // 0
	"01", // 1
	"17", // 23
	"1818", // 24
	"190100", // 256
	"1a00010000", // 65536
	"1b0000000100000000", // 4294967296
	"20", // -1
	"37", // -24
	"3818", // -25
	"390100", // -257
	"3a00010000", // -65537
	"3b0000000100000000", // -4294967297
	"4161", // h"a"
	"6161", // "a"
	"80", // []
	"8100", // [0]
	"820102", // [1,2]
	"818100", // [[0]]
	"a1616100", // {"a":0}
	"d8184100", // tag
	"f4", // false
	"f5", // true
	"f6", // null
	"f7", // undefined
	"f8ff", // simple(255)
	#ifndef CBOR_NO_FLOAT
	"f93c00", // 1.0
	"f9bc00", // -1.0
	"f903ff", // 6.097555160522461e-05
	"f90400", // 6.103515625e-05
	"f907ff", // 0.00012201070785522461
	"f90800", // 0.0001220703125
	"fa47800000", // 65536.0
	"fb3ff199999999999a", // 1.1
	"f97e00", // NaN
	#endif /* CBOR_NO_FLOAT */
	"5f42010243030405ff", // (_ h'0102', h'030405')
	"7f61616161ff", // (_ "a", "a")
	"9fff", // [_ ]
	"9f9f9fffffff", // [_ [_ [_ ]]]
	"9f009f00ff00ff", // [_ 0, [_ 0], 0]
	"bf61610161629f0203ffff", // {_ "a": 1, "b": [_ 2, 3]}
	};
	cn_cbor *cb;
	buffer b;
	size_t i;
	unsigned char encoded[1024];
	ssize_t enc_sz;
	ssize_t enc_sz2;

	for (i = 0; i < sizeof(tests) / sizeof(char *); i++) {
	ASSERT_TRUE(parse_hex(tests[i], &b));
	err.err = CN_CBOR_NO_ERROR;
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	// CTEST_LOG("%s: %s", tests[i], cn_cbor_error_str[err.err]);
	ASSERT_EQUAL(err.err, CN_CBOR_NO_ERROR);
	ASSERT_NOT_NULL(cb);

	enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb);
	enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb);
	ASSERT_EQUAL(enc_sz, enc_sz2);
	ASSERT_DATA(b.ptr, b.sz, encoded, enc_sz);
	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}
	}

	CTEST(cbor, parse_normalize)
	{
	cn_cbor_errback err;
	char *basic_tests[] = {
	"00",
	"00", // 0
	"1800",
	"00",
	"1818",
	"1818",
	"190000",
	"00",
	"190018",
	"1818",
	"1a00000000",
	"00",
	"1b0000000000000000",
	"00",
	"20",
	"20", // -1
	"3800",
	"20",
	"c600",
	"c600", // 6(0) (undefined tag)
	"d80600",
	"c600",
	"d9000600",
	"c600",
	};
	char *float_tests[] = {
	"fb3ff0000000000000", "f93c00", // 1.0
	"fbbff0000000000000", "f9bc00", // -1.0
	"fb40f86a0000000000", "fa47c35000", // 100000.0
	"fb7ff8000000000000", "f97e00", // NaN
	"fb3e70000000000000", "f90001", // 5.960464477539063e-08
	"fb3e78000000000000", "fa33c00000", // 8.940696716308594e-08
	"fb3e80000000000000", "f90002", // 1.1920928955078125e-07
	};
	cn_cbor *cb;
	buffer b, b2;
	size_t i;
	unsigned char encoded[1024];
	ssize_t enc_sz;
	ssize_t enc_sz2;

	for (i = 0; i < sizeof(basic_tests) / sizeof(char *); i += 2) {
	ASSERT_TRUE(parse_hex(basic_tests[i], &b));
	ASSERT_TRUE(parse_hex(basic_tests[i + 1], &b2));
	err.err = CN_CBOR_NO_ERROR;
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	CTEST_LOG("%s: %s", basic_tests[i], cn_cbor_error_str[err.err]);
	ASSERT_EQUAL(err.err, CN_CBOR_NO_ERROR);
	ASSERT_NOT_NULL(cb);

	enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb);
	enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb);
	ASSERT_EQUAL(enc_sz, enc_sz2);
	ASSERT_DATA(b2.ptr, b2.sz, encoded, enc_sz);
	free(b.ptr);
	free(b2.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}

	for (i = 0; i < sizeof(float_tests) / sizeof(char *); i += 2) {
	ASSERT_TRUE(parse_hex(float_tests[i], &b));
	ASSERT_TRUE(parse_hex(float_tests[i + 1], &b2));
	err.err = CN_CBOR_NO_ERROR;
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	CTEST_LOG("%s: %s", float_tests[i], cn_cbor_error_str[err.err]);
	#ifndef CBOR_NO_FLOAT
	ASSERT_EQUAL(err.err, CN_CBOR_NO_ERROR);
	ASSERT_NOT_NULL(cb);
	#else /* CBOR_NO_FLOAT */
	ASSERT_EQUAL(err.err, CN_CBOR_ERR_FLOAT_NOT_SUPPORTED);
	ASSERT_NULL(cb);
	#endif /* CBOR_NO_FLOAT */

	/* enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb); */
	/* enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb); */
	/* ASSERT_EQUAL(enc_sz, enc_sz2); */
	/* ASSERT_DATA(b2.ptr, b2.sz, encoded, enc_sz); */
	free(b.ptr);
	free(b2.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}
	}

	typedef struct _cbor_failure {
	char *hex;
	cn_cbor_error err;
	} cbor_failure;

	CTEST(cbor, fail)
	{
	cn_cbor_errback err;
	cbor_failure tests[] = {
	{"81", CN_CBOR_ERR_OUT_OF_DATA},
	{"0000", CN_CBOR_ERR_NOT_ALL_DATA_CONSUMED},
	{"bf00ff", CN_CBOR_ERR_ODD_SIZE_INDEF_MAP},
	{"ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"1f", CN_CBOR_ERR_MT_UNDEF_FOR_INDEF},
	{"1c", CN_CBOR_ERR_RESERVED_AI},
	{"7f4100", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	};
	cn_cbor *cb;
	buffer b;
	size_t i;
	uint8_t buf[10];
	cn_cbor inv = {CN_CBOR_INVALID, 0, {0}, 0, NULL, NULL, NULL, NULL};

	ASSERT_EQUAL(-1, cn_cbor_encoder_write(buf, 0, sizeof(buf), &inv));

	for (i = 0; i < sizeof(tests) / sizeof(cbor_failure); i++) {
	ASSERT_TRUE(parse_hex(tests[i].hex, &b));
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	ASSERT_NULL(cb);
	ASSERT_EQUAL(err.err, tests[i].err);

	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}
	}

	// Decoder loses float size information
	CTEST(cbor, float)
	{
	#ifndef CBOR_NO_FLOAT
	cn_cbor_errback err;
	char *tests[] = {
	"f90001", // 5.960464477539063e-08
	"f9c400", // -4.0
	"fa47c35000", // 100000.0
	"f97e00", // Half NaN, half beast
	"f9fc00", // -Inf
	"f97c00", // Inf
	};
	cn_cbor *cb;
	buffer b;
	size_t i;
	unsigned char encoded[1024];
	ssize_t enc_sz;
	ssize_t enc_sz2;

	for (i = 0; i < sizeof(tests) / sizeof(char *); i++) {
	ASSERT_TRUE(parse_hex(tests[i], &b));
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb);

	enc_sz2 = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), cb);
	enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), cb);
	ASSERT_EQUAL(enc_sz, enc_sz2);
	ASSERT_DATA(b.ptr, b.sz, encoded, enc_sz);

	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}
	#endif /* CBOR_NO_FLOAT */
	}

	CTEST(cbor, getset)
	{
	buffer b;
	cn_cbor *cb;
	cn_cbor *val;
	cn_cbor_errback err;

	ASSERT_TRUE(parse_hex("a40000436363630262626201616100", &b));
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb);
	val = cn_cbor_mapget_string(cb, "a");
	ASSERT_NOT_NULL(val);
	val = cn_cbor_mapget_string(cb, "bb");
	ASSERT_NOT_NULL(val);
	val = cn_cbor_mapget_string(cb, "ccc");
	ASSERT_NOT_NULL(val);
	val = cn_cbor_mapget_string(cb, "b");
	ASSERT_NULL(val);
	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);

	ASSERT_TRUE(parse_hex("a3616100006161206162", &b));
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb);
	val = cn_cbor_mapget_int(cb, 0);
	ASSERT_NOT_NULL(val);
	val = cn_cbor_mapget_int(cb, -1);
	ASSERT_NOT_NULL(val);
	val = cn_cbor_mapget_int(cb, 1);
	ASSERT_NULL(val);
	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);

	ASSERT_TRUE(parse_hex("8100", &b));
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb);
	val = cn_cbor_index(cb, 0);
	ASSERT_NOT_NULL(val);
	val = cn_cbor_index(cb, 1);
	ASSERT_NULL(val);
	val = cn_cbor_index(cb, -1);
	ASSERT_NULL(val);
	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}

	CTEST(cbor, create)
	{
	cn_cbor_errback err;
	const cn_cbor *val;
	const char *data = "abc";
	cn_cbor *cb_map = cn_cbor_map_create(CONTEXT_NULL_COMMA & err);
	cn_cbor *cb_int;
	cn_cbor *cb_data;
	#ifndef CBOR_NO_FLOAT
	cn_cbor *cb_dbl;
	#endif

	ASSERT_NOT_NULL(cb_map);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);

	cb_int = cn_cbor_int_create(256 CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb_int);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);

	cb_data = cn_cbor_data_create((const uint8_t *)data, 4 CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb_data);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);

	#ifndef CBOR_NO_FLOAT
	cb_dbl = cn_cbor_double_create(3.14159 CONTEXT_NULL, &err);
	ASSERT_NOT_NULL(cb_dbl);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	#endif

	cn_cbor_mapput_int(cb_map, 5, cb_int CONTEXT_NULL, &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_TRUE(cb_map->length == 2);

	cn_cbor_mapput_int(cb_map, -7, cb_data CONTEXT_NULL, &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_TRUE(cb_map->length == 4);

	cn_cbor_mapput_string(cb_map, "foo", cn_cbor_string_create(data CONTEXT_NULL, &err) CONTEXT_NULL, &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_TRUE(cb_map->length == 6);

	cn_cbor_map_put(
	cb_map, cn_cbor_string_create("bar" CONTEXT_NULL, &err), cn_cbor_string_create("qux" CONTEXT_NULL, &err), &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_TRUE(cb_map->length == 8);

	#ifndef CBOR_NO_FLOAT
	cn_cbor_mapput_int(cb_map, 42, cb_dbl CONTEXT_NULL, &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_TRUE(cb_map->length == 10);
	#endif

	val = cn_cbor_mapget_int(cb_map, 5);
	ASSERT_NOT_NULL(val);
	ASSERT_TRUE(val->v.sint == 256);

	val = cn_cbor_mapget_int(cb_map, -7);
	ASSERT_NOT_NULL(val);
	ASSERT_STR(val->v.str, "abc");

	#ifndef CBOR_NO_FLOAT
	val = cn_cbor_mapget_int(cb_map, 42);
	ASSERT_NOT_NULL(val);
	ASSERT_TRUE(val->v.dbl > 3.14 && val->v.dbl < 3.15);
	#endif

	cn_cbor_free(cb_map CONTEXT_NULL);
	}

	CTEST(cbor, map_errors)
	{
	cn_cbor_errback err;
	cn_cbor *ci;
	ci = cn_cbor_int_create(65536, CONTEXT_NULL_COMMA & err);
	cn_cbor_mapput_int(ci, -5, NULL, CONTEXT_NULL_COMMA & err);
	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
	cn_cbor_mapput_string(ci, "foo", NULL, CONTEXT_NULL_COMMA & err);
	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
	cn_cbor_map_put(ci, NULL, NULL, &err);
	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
	cn_cbor_free(ci CONTEXT_NULL);
	}

	CTEST(cbor, array)
	{
	cn_cbor_errback err;
	cn_cbor *a = cn_cbor_array_create(CONTEXT_NULL_COMMA & err);
	ASSERT_NOT_NULL(a);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_EQUAL(a->length, 0);

	cn_cbor_array_append(a, cn_cbor_int_create(256, CONTEXT_NULL_COMMA & err), &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_EQUAL(a->length, 1);

	cn_cbor_array_append(a, cn_cbor_string_create("five", CONTEXT_NULL_COMMA & err), &err);
	ASSERT_TRUE(err.err == CN_CBOR_NO_ERROR);
	ASSERT_EQUAL(a->length, 2);
	cn_cbor_free(a CONTEXT_NULL);
	}

	CTEST(cbor, array_errors)
	{
	cn_cbor_errback err;
	cn_cbor *ci = cn_cbor_int_create(12, CONTEXT_NULL_COMMA & err);
	cn_cbor_array_append(NULL, ci, &err);
	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
	cn_cbor_array_append(ci, NULL, &err);
	ASSERT_EQUAL(err.err, CN_CBOR_ERR_INVALID_PARAMETER);
	cn_cbor_free(ci CONTEXT_NULL);
	}

	CTEST(cbor, create_encode)
	{
	cn_cbor *map;
	cn_cbor *cdata;
	char data[] = "data";
	unsigned char encoded[1024];
	ssize_t enc_sz;

	map = cn_cbor_map_create(CONTEXT_NULL_COMMA NULL);
	ASSERT_NOT_NULL(map);

	cdata = cn_cbor_data_create((uint8_t *)data, sizeof(data) - 1, CONTEXT_NULL_COMMA NULL);
	ASSERT_NOT_NULL(cdata);

	ASSERT_TRUE(cn_cbor_mapput_int(map, 0, cdata, CONTEXT_NULL_COMMA NULL));
	enc_sz = cn_cbor_encoder_write(NULL, 0, sizeof(encoded), map);
	ASSERT_EQUAL(7, enc_sz);
	enc_sz = cn_cbor_encoder_write(encoded, 0, sizeof(encoded), map);
	ASSERT_EQUAL(7, enc_sz);
	cn_cbor_free(map CONTEXT_NULL);
	}

	CTEST(cbor, fail2)
	{
	cn_cbor_errback err;
	cbor_failure tests[] = {
	// * End of input in a head:
	{"18", CN_CBOR_ERR_OUT_OF_DATA},
	{"19", CN_CBOR_ERR_OUT_OF_DATA},
	{"1a", CN_CBOR_ERR_OUT_OF_DATA},
	{"1b", CN_CBOR_ERR_OUT_OF_DATA},
	{"1901", CN_CBOR_ERR_OUT_OF_DATA},
	{"1a0102", CN_CBOR_ERR_OUT_OF_DATA},
	{"1b01020304050607", CN_CBOR_ERR_OUT_OF_DATA},
	{"38", CN_CBOR_ERR_OUT_OF_DATA},
	{"58", CN_CBOR_ERR_OUT_OF_DATA},
	{"78", CN_CBOR_ERR_OUT_OF_DATA},
	{"98", CN_CBOR_ERR_OUT_OF_DATA},
	{"9a01ff00", CN_CBOR_ERR_OUT_OF_DATA},
	{"b8", CN_CBOR_ERR_OUT_OF_DATA},
	{"d8", CN_CBOR_ERR_OUT_OF_DATA},
	{"f8", CN_CBOR_ERR_OUT_OF_DATA},
	{"f900", CN_CBOR_ERR_OUT_OF_DATA},
	{"fa0000", CN_CBOR_ERR_OUT_OF_DATA},
	{"fb000000", CN_CBOR_ERR_OUT_OF_DATA},

	// * Definite length strings with short data:
	{"41", CN_CBOR_ERR_OUT_OF_DATA},
	{"61", CN_CBOR_ERR_OUT_OF_DATA},
	{"5affffffff00", CN_CBOR_ERR_OUT_OF_DATA},
	{"5bffffffffffffffff010203", CN_CBOR_ERR_OUT_OF_DATA},
	{"7affffffff00", CN_CBOR_ERR_OUT_OF_DATA},
	{"7b7fffffffffffffff010203", CN_CBOR_ERR_OUT_OF_DATA},

	// * Definite length maps and arrays not closed with enough items:
	{"81", CN_CBOR_ERR_OUT_OF_DATA},
	{"818181818181818181", CN_CBOR_ERR_OUT_OF_DATA},
	{"8200", CN_CBOR_ERR_OUT_OF_DATA},
	{"a1", CN_CBOR_ERR_OUT_OF_DATA},
	{"a20102", CN_CBOR_ERR_OUT_OF_DATA},
	{"a100", CN_CBOR_ERR_OUT_OF_DATA},
	{"a2000000", CN_CBOR_ERR_OUT_OF_DATA},

	// * Tag number not followed by tag content:
	{"c0", CN_CBOR_ERR_OUT_OF_DATA},

	// * Indefinite length strings not closed by a break stop code:
	{"5f4100", CN_CBOR_ERR_OUT_OF_DATA}, {"7f6100", CN_CBOR_ERR_OUT_OF_DATA},

	// * Indefinite length maps and arrays not closed by a break stop code:
	{"9f", CN_CBOR_ERR_OUT_OF_DATA}, {"9f0102", CN_CBOR_ERR_OUT_OF_DATA}, {"bf", CN_CBOR_ERR_OUT_OF_DATA},
	{"bf01020102", CN_CBOR_ERR_OUT_OF_DATA}, {"819f", CN_CBOR_ERR_OUT_OF_DATA}, {"9f8000", CN_CBOR_ERR_OUT_OF_DATA},
	{"9f9f9f9f9fffffffff", CN_CBOR_ERR_OUT_OF_DATA}, {"9f819f819f9fffffff", CN_CBOR_ERR_OUT_OF_DATA},

	// * Reserved additional information values:
	{"1c", CN_CBOR_ERR_RESERVED_AI},
	{"1d", CN_CBOR_ERR_RESERVED_AI},
	{"1e", CN_CBOR_ERR_RESERVED_AI},
	{"3c", CN_CBOR_ERR_RESERVED_AI},
	{"3d", CN_CBOR_ERR_RESERVED_AI},
	{"3e", CN_CBOR_ERR_RESERVED_AI},
	{"5c", CN_CBOR_ERR_RESERVED_AI},
	{"5d", CN_CBOR_ERR_RESERVED_AI},
	{"5e", CN_CBOR_ERR_RESERVED_AI},
	{"7c", CN_CBOR_ERR_RESERVED_AI},
	{"7d", CN_CBOR_ERR_RESERVED_AI},
	{"7e", CN_CBOR_ERR_RESERVED_AI},
	{"9c", CN_CBOR_ERR_RESERVED_AI},
	{"9d", CN_CBOR_ERR_RESERVED_AI},
	{"9e", CN_CBOR_ERR_RESERVED_AI},
	{"bc", CN_CBOR_ERR_RESERVED_AI},
	{"bd", CN_CBOR_ERR_RESERVED_AI},
	{"be", CN_CBOR_ERR_RESERVED_AI},
	{"dc", CN_CBOR_ERR_RESERVED_AI},
	{"dd", CN_CBOR_ERR_RESERVED_AI},
	{"de", CN_CBOR_ERR_RESERVED_AI},
	{"fc", CN_CBOR_ERR_RESERVED_AI},
	{"fd", CN_CBOR_ERR_RESERVED_AI},
	{"fe", CN_CBOR_ERR_RESERVED_AI},

	// * Reserved two-byte encodings of simple types:
	#if 0
	{"f800", CN_CBOR_ERR_RESERVED_AI},
	{"f801", CN_CBOR_ERR_RESERVED_AI},
	{"f818", CN_CBOR_ERR_RESERVED_AI},
	{"f81f", CN_CBOR_ERR_RESERVED_AI},
	#endif

	// * Indefinite length string chunks not of the correct type:
	{"5f00ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"5f21ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"5f6100ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"5f80ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"5fa0ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"5fc000ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"5fe0ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"7f4100ff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},

	// * Indefinite length string chunks not definite length:
	{"5f5f4100ffff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},
	{"7f7f6100ffff", CN_CBOR_ERR_WRONG_NESTING_IN_INDEF_STRING},

	// * Break occurring on its own outside of an indefinite length item:
	{"ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},

	// * Break occurring in a definite length array or map or a tag:
	{"81ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"8200ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"a1ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"a1ff00", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"a100ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"a20000ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"9f81ff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},
	{"9f829f819f9fffffffff", CN_CBOR_ERR_BREAK_OUTSIDE_INDEF},

	// * Break in indefinite length map would lead to odd number of items (break in a value position):
	{"bf00ff", CN_CBOR_ERR_ODD_SIZE_INDEF_MAP},
	{"bf000000ff", CN_CBOR_ERR_ODD_SIZE_INDEF_MAP},

	// * Major type 0, 1, 6 with additional information 31:
	{"1f", CN_CBOR_ERR_MT_UNDEF_FOR_INDEF},
	{"3f", CN_CBOR_ERR_MT_UNDEF_FOR_INDEF},
	{"df", CN_CBOR_ERR_OUT_OF_DATA}
	};
	cn_cbor *cb;
	buffer b;
	size_t i;
	uint8_t buf[10];
	cn_cbor inv = {CN_CBOR_INVALID, 0, {0}, 0, NULL, NULL, NULL, NULL};

	ASSERT_EQUAL(-1, cn_cbor_encoder_write(buf, 0, sizeof(buf), &inv));

	for (i = 0; i < sizeof(tests) / sizeof(cbor_failure); i++) {
	ASSERT_TRUE(parse_hex(tests[i].hex, &b));
	cb = cn_cbor_decode(b.ptr, b.sz CONTEXT_NULL, &err);
	// CTEST_LOG("%s: %s %s", tests[i].hex, cn_cbor_error_str[tests[i].err], cn_cbor_error_str[err.err]);
	ASSERT_NULL(cb);
	ASSERT_EQUAL(err.err, tests[i].err);

	free(b.ptr);
	cn_cbor_free(cb CONTEXT_NULL);
	}
	}