diff --git a/src/cn-cbor.c b/src/cn-cbor.c
index dd2728d..0db1851 100644
--- a/src/cn-cbor.c
+++ b/src/cn-cbor.c
@@ -249,8 +249,8 @@
 		case MT_TEXT:
 			cb->v.str = (char *)pos;
 			cb->length = (size_t)val;
-			TAKE(pos, ebuf, val, ;);
 			cb->flags |= CN_CBOR_FL_EXT_DATA;
+			TAKE(pos, ebuf, val, ;);
 			break;
 		case MT_MAP:
 			val <<= 1;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index f413543..66fbe6d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -17,6 +17,7 @@
 create_test(cbor)
 # create_test(file)
 create_test(memory)
+target_sources(cbor_test PRIVATE context.c)
 target_sources(memory_test PRIVATE context.c)
 include(CTest)
 
diff --git a/test/cbor_test.c b/test/cbor_test.c
index 27a4afd..a379c5a 100644
--- a/test/cbor_test.c
+++ b/test/cbor_test.c
@@ -19,18 +19,34 @@
 #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[])
 {
-	return ctest_main(argc, 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 , NULL
-#define CONTEXT_NULL_COMMA NULL,
+#define CONTEXT_NULL , context
+#define CONTEXT_NULL_COMMA context,
 #else
 #define CONTEXT_NULL
 #define CONTEXT_NULL_COMMA
@@ -436,6 +452,8 @@
 	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)
@@ -453,6 +471,7 @@
 	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)
@@ -463,6 +482,7 @@
 	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)
@@ -484,4 +504,147 @@
 	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);
+	}
 }
diff --git a/test/ctest.h b/test/ctest.h
index 2d9cbae..1142a1b 100644
--- a/test/ctest.h
+++ b/test/ctest.h
@@ -168,7 +168,7 @@
 
 static size_t ctest_errorsize;
 static char* ctest_errormsg;
-#define MSG_SIZE 4096
+#define MSG_SIZE 2*4096
 static char ctest_errorbuffer[MSG_SIZE];
 static jmp_buf ctest_err;
 static int color_output = 1;