small improvements, make check_memory compile

include/ua_types.h

@@ -218,8 +218,8 @@ typedef struct UA_DataType UA_DataType;
     memory, or functions from which the data can be accessed. Variants are replaced together with
     the data they store (exception: use a data source).*/
 typedef struct {
-    const UA_DataType *dataType;
-    UA_NodeId dataTypeId;
+    const UA_DataType *type;
+    UA_NodeId typeId;
     enum {
         UA_VARIANT_DATA, ///< The data is "owned" by this variant (copied and deleted together)
         UA_VARIANT_DATA_NODELETE, /**< The data is "borrowed" by the variant and shall not be

src/ua_types.c

@@ -607,15 +607,15 @@ void UA_Variant_init(UA_Variant *p) {
     p->storage.data.dataPtr        = UA_NULL;
     p->storage.data.arrayDimensions       = UA_NULL;
     p->storage.data.arrayDimensionsLength = -1;
-    UA_NodeId_init(&p->dataTypeId);
-    p->dataType = UA_NULL;
+    UA_NodeId_init(&p->typeId);
+    p->type = UA_NULL;
 }
 
 UA_TYPE_DELETE_DEFAULT(UA_Variant)
 void UA_Variant_deleteMembers(UA_Variant *p) {
     if(p->storageType == UA_VARIANT_DATA) {
         if(p->storage.data.dataPtr) {
-            UA_Array_delete(p->storage.data.dataPtr, p->storage.data.arrayLength, p->dataType);
+            UA_Array_delete(p->storage.data.dataPtr, p->storage.data.arrayLength, p->type);
             p->storage.data.dataPtr = UA_NULL;
             p->storage.data.arrayLength = 0;
         }
@@ -627,7 +627,7 @@ void UA_Variant_deleteMembers(UA_Variant *p) {
         return;
     }
 
-    UA_NodeId_deleteMembers(&p->dataTypeId);
+    UA_NodeId_deleteMembers(&p->typeId);
 
     if(p->storageType == UA_VARIANT_DATASOURCE) {
         p->storage.datasource.delete(p->storage.datasource.handle);
@@ -652,11 +652,11 @@ UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
     }
 
     /* 2) Copy the data to the destination */
-    retval |= UA_Array_copy(srcdata->dataPtr, srcdata->arrayLength, &dstdata->dataPtr, src->dataType);
+    retval |= UA_Array_copy(srcdata->dataPtr, srcdata->arrayLength, &dstdata->dataPtr, src->type);
     if(retval == UA_STATUSCODE_GOOD) {
         dst->storageType = UA_VARIANT_DATA;
-        dst->dataType= src->dataType;
-        UA_NodeId_copy(&src->dataTypeId, &dst->dataTypeId);
+        dst->type= src->type;
+        UA_NodeId_copy(&src->typeId, &dst->typeId);
         dstdata->arrayLength = srcdata->arrayLength;
         if(srcdata->arrayDimensions) {
             retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength,
@@ -680,8 +680,8 @@ UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
 /** Copies data into a variant. The target variant has always a storagetype UA_VARIANT_DATA */
 UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const void *p, UA_UInt16 typeIndex) {
     UA_Variant_init(v);
-    v->dataType = &UA_TYPES[typeIndex];
-    v->dataTypeId = (UA_NodeId){.namespaceIndex = 0,
+    v->type = &UA_TYPES[typeIndex];
+    v->typeId = (UA_NodeId){.namespaceIndex = 0,
                                 .identifierType = UA_NODEIDTYPE_NUMERIC,
                                 .identifier.numeric = UA_TYPES_IDS[typeIndex]};
     v->storage.data.arrayLength = 1; // no array but a single entry
@@ -699,10 +699,10 @@ UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const void *p, UA_UInt16 ty
 
 UA_StatusCode UA_Variant_copySetArray(UA_Variant *v, const void *array, UA_Int32 noElements, UA_UInt16 typeIndex) {
     UA_Variant_init(v);
-    v->dataType = &UA_TYPES[typeIndex];
-    v->dataTypeId = (UA_NodeId){.namespaceIndex = 0,
-                                .identifierType = UA_NODEIDTYPE_NUMERIC,
-                                .identifier.numeric = UA_TYPES_IDS[typeIndex]};
+    v->type = &UA_TYPES[typeIndex];
+    v->typeId = (UA_NodeId){.namespaceIndex = 0,
+                            .identifierType = UA_NODEIDTYPE_NUMERIC,
+                            .identifier.numeric = UA_TYPES_IDS[typeIndex]};
     v->storage.data.arrayLength = noElements;
     UA_StatusCode retval = UA_Array_copy(array, noElements, &v->storage.data.dataPtr, &UA_TYPES[typeIndex]);
     if(retval) {

src/ua_types_encoding_binary.c

@@ -764,9 +764,9 @@ UA_UInt32 UA_Variant_calcSizeBinary(UA_Variant const *p) {
     if(arrayLength < 1) {
         length += 4; // length
     } else {
-        length += UA_Array_calcSizeBinary(data->dataPtr, arrayLength, p->dataType);
+        length += UA_Array_calcSizeBinary(data->dataPtr, arrayLength, p->type);
         // if the type is not builtin, we encode it as an extensionobject
-        if(!p->dataType->namespaceZero || p->dataType->typeIndex > 24)
+        if(!p->type->namespaceZero || p->type->typeIndex > 24)
             length += 9 * arrayLength;  // overhead for extensionobjects: 4 byte nodeid + 1 byte encoding + 4 byte bytestring length
     }
 
@@ -791,7 +791,7 @@ UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst,
     UA_Byte encodingByte = 0;
     UA_Boolean isArray = data->arrayLength != 1;  // a single element is not an array
     UA_Boolean hasDimensions = isArray && data->arrayDimensions != UA_NULL;
-    UA_Boolean isBuiltin = (src->dataType->namespaceZero && src->dataType->typeIndex <= 24);
+    UA_Boolean isBuiltin = (src->type->namespaceZero && src->type->typeIndex <= 24);
 
     if(isArray) {
         encodingByte |= UA_VARIANT_ENCODINGMASKTYPE_ARRAY;
@@ -800,26 +800,26 @@ UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst,
     }
 
     if(isBuiltin)
-        encodingByte |= UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK & (UA_Byte)UA_TYPES_IDS[src->dataType->typeIndex];
+        encodingByte |= UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK & (UA_Byte)UA_TYPES_IDS[src->type->typeIndex];
     else
         encodingByte |= UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK & (UA_Byte)22;  // ExtensionObject
 
     UA_StatusCode retval = UA_Byte_encodeBinary(&encodingByte, dst, offset);
 
     if(isArray)
-        retval |= UA_Array_encodeBinary(data->dataPtr, data->arrayLength, src->dataType, dst, offset);
+        retval |= UA_Array_encodeBinary(data->dataPtr, data->arrayLength, src->type, dst, offset);
     else if(!data->dataPtr)
         retval = UA_STATUSCODE_BADENCODINGERROR; // an array can be empty. a single element must be present.
     else {
         if(!isBuiltin) {
             // print the extensionobject header
-            UA_NodeId_encodeBinary(&src->dataTypeId, dst, offset);
+            UA_NodeId_encodeBinary(&src->typeId, dst, offset);
             UA_Byte eoEncoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
             UA_Byte_encodeBinary(&eoEncoding, dst, offset);
-            UA_Int32 eoEncodingLength = UA_calcSizeBinary(data->dataPtr, src->dataType);
+            UA_Int32 eoEncodingLength = UA_calcSizeBinary(data->dataPtr, src->type);
             UA_Int32_encodeBinary(&eoEncodingLength, dst, offset);
         }
-        retval |= UA_encodeBinary(data->dataPtr, src->dataType, dst, offset);
+        retval |= UA_encodeBinary(data->dataPtr, src->type, dst, offset);
     }
 
     if(hasDimensions)
@@ -877,8 +877,8 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src, UA_UInt32 *offse
             data->arrayLength = -1; // for deleteMembers
     }
 
-    dst->dataType = dataType;
-    dst->dataTypeId = typeid;
+    dst->type = dataType;
+    dst->typeId = typeid;
 
     if(retval)
         UA_Variant_deleteMembers(dst);

tests/check_builtin.c

@@ -274,7 +274,7 @@ START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {
 	// given
 	UA_Variant arg;
 	UA_Variant_init(&arg);
-    arg.dataType = &UA_TYPES[UA_TYPES_INT32];
+    arg.type = &UA_TYPES[UA_TYPES_INT32];
 #define ARRAY_LEN 8
 	arg.storage.data.arrayLength = ARRAY_LEN;
 	UA_Int32 *data[ARRAY_LEN];
@@ -293,7 +293,7 @@ START_TEST(UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize) {
 	// given
 	UA_Variant arg;
 	UA_Variant_init(&arg);
-	arg.dataType = &UA_TYPES[UA_TYPES_STRING];
+	arg.type = &UA_TYPES[UA_TYPES_STRING];
 #define ARRAY_LEN 3
 	arg.storage.data.arrayLength = ARRAY_LEN;
 	UA_String strings[3];
@@ -683,7 +683,7 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 5);
-	ck_assert_ptr_eq((const void *)dst.dataType, (const void *)&UA_TYPES[UA_TYPES_INT32]);
+	ck_assert_ptr_eq((const void *)dst.type, (const void *)&UA_TYPES[UA_TYPES_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 1);
 	ck_assert_int_eq(*(UA_Int32 *)dst.storage.data.dataPtr, 255);
 	// finally
@@ -706,7 +706,7 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 1+4+2*4);
-	ck_assert_ptr_eq((const void*)dst.dataType, (const void*)&UA_TYPES[UA_TYPES_INT32]);
+	ck_assert_ptr_eq((const void*)dst.type, (const void*)&UA_TYPES[UA_TYPES_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 2);
 	ck_assert_int_eq(((UA_Int32 *)dst.storage.data.dataPtr)[0], 255);
 	ck_assert_int_eq(((UA_Int32 *)dst.storage.data.dataPtr)[1], -1);
@@ -1139,7 +1139,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
     src.hasVariant = UA_TRUE;
     src.hasServerTimestamp = UA_TRUE;
 	UA_Variant_init(&src.value);
-	src.value.dataType = &UA_TYPES[UA_TYPES_INT32];
+	src.value.type = &UA_TYPES[UA_TYPES_INT32];
 	src.value.storage.data.arrayLength  = 1; // one element (encoded as not an array)
 	UA_Int32  vdata  = 45;
 	src.value.storage.data.dataPtr = (void *)&vdata;
@@ -1473,7 +1473,7 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	UA_Variant_init(&copiedValue);
 	value.storage.data.dataPtr = UA_malloc(sizeof(UA_String));
 	*((UA_String*)value.storage.data.dataPtr) = testString;
-    value.dataType = &UA_TYPES[UA_TYPES_STRING];
+    value.type = &UA_TYPES[UA_TYPES_STRING];
 	value.storage.data.arrayLength = 1;
 
 	//when
@@ -1515,7 +1515,7 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	value.storage.data.dataPtr = (void *)srcArray;
 	value.storage.data.arrayDimensionsLength = 1;
 	value.storage.data.arrayDimensions = dimensions;
-	value.dataType = &UA_TYPES[UA_TYPES_STRING];
+	value.type = &UA_TYPES[UA_TYPES_STRING];
 
 	//when
 	UA_Variant_copy(&value, &copiedValue);
@@ -1570,7 +1570,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	value.storage.data.dataPtr     = srcArray;
 	value.storage.data.arrayDimensionsLength = 2;
 	value.storage.data.arrayDimensions       = dimensions;
-	value.dataType = &UA_TYPES[UA_TYPES_INT32];
+	value.type = &UA_TYPES[UA_TYPES_INT32];
 
 	//when
 	UA_Variant_copy(&value, &copiedValue);
@@ -1613,7 +1613,7 @@ START_TEST(UA_ExtensionObject_encodeDecodeShallWorkOnExtensionObject) {
 	/* wrap it into a variant */
 	UA_Variant varVal;
 	UA_Variant_init(&varVal);
-	varVal.dataType = &UA_TYPES[UA_TYPES_INT32];
+	varVal.type = &UA_TYPES[UA_TYPES_INT32];
 	varVal.storage.data.dataPtr = &val;
 	varVal.storage.data.arrayDimensionsLength = -1;
 	varVal.storage.data.arrayDimensions = UA_NULL;

tests/check_memory.c

@@ -3,21 +3,18 @@
 #include <stdlib.h>
 
 #include "ua_types.h"
+#include "ua_types_generated.h"
+#include "ua_types_encoding_binary.h"
 #include "ua_util.h"
-#include "ua_namespace_0.h"
 #include "check.h"
 
 START_TEST(newAndEmptyObjectShallBeDeleted) {
 	// given
-	void *obj = UA_TYPES[_i].new();
-	// when
-#ifdef DEBUG //no print functions if not in debug mode
-	UA_TYPES[_i].print(obj, stdout);
-#endif
+	void *obj = UA_new(&UA_TYPES[_i]);
 	// then
 	ck_assert_ptr_ne(obj, UA_NULL);
     // finally
-	UA_TYPES[_i].delete(obj);
+	UA_delete(obj, &UA_TYPES[_i]);
 }
 END_TEST
 
@@ -29,7 +26,7 @@ START_TEST(arrayCopyShallMakeADeepCopy) {
 	a1[2] = (UA_String){3, (UA_Byte*)"ccc"};
 	// when
 	UA_String *a2;
-	UA_Int32   retval = UA_Array_copy((const void *)a1, 3, &UA_TYPES[UA_STRING], (void **)&a2);
+	UA_Int32   retval = UA_Array_copy((const void *)a1, 3, (void **)&a2, &UA_TYPES[UA_TYPES_STRING]);
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(a1[0].length, 1);
@@ -45,7 +42,7 @@ START_TEST(arrayCopyShallMakeADeepCopy) {
 	ck_assert_int_eq(a1[1].data[0], a2[1].data[0]);
 	ck_assert_int_eq(a1[2].data[0], a2[2].data[0]);
 	// finally
-	UA_Array_delete((void *)a2, 3, &UA_TYPES[UA_STRING]);
+	UA_Array_delete((void *)a2, 3, &UA_TYPES[UA_TYPES_STRING]);
 }
 END_TEST
 
@@ -53,31 +50,31 @@ START_TEST(encodeShallYieldDecode) {
 	// given
 	UA_ByteString msg1, msg2;
 	UA_UInt32     pos = 0;
-	void *obj1 = UA_TYPES[_i].new();
-	UA_ByteString_newMembers(&msg1, UA_TYPES[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
-	UA_StatusCode retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
+	void *obj1 = UA_new(&UA_TYPES[_i]);
+	UA_ByteString_newMembers(&msg1, UA_calcSizeBinary(obj1, &UA_TYPES[_i]));
+    UA_StatusCode retval = UA_encodeBinary(obj1, &UA_TYPES[_i], &msg1, &pos);
 	if(retval != UA_STATUSCODE_GOOD) {
 		// this happens, e.g. when we encode a variant (with UA_TYPES[UA_INVALIDTYPE] in the vtable)
-		UA_TYPES[_i].delete(obj1);
+		UA_delete(obj1, &UA_TYPES[_i]);
 		UA_ByteString_deleteMembers(&msg1);
 		return;	
 	}
 
 	// when
-	void *obj2 = UA_TYPES[_i].new();
-	pos = 0; retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].decode(&msg1, &pos, obj2);
-	ck_assert_msg(retval == UA_STATUSCODE_GOOD, "messages differ idx=%d,name=%s", _i, UA_TYPES[_i].name);
-	retval = UA_ByteString_newMembers(&msg2, UA_TYPES[_i].encodings[UA_ENCODING_BINARY].calcSize(obj2));
+	void *obj2 = UA_new(&UA_TYPES[_i]);
+	pos = 0; retval = UA_decodeBinary(&msg1, &pos, obj2, &UA_TYPES[_i]);
+	ck_assert_msg(retval == UA_STATUSCODE_GOOD, "messages differ idx=%d,nodeid=%i", _i, UA_TYPES_IDS[_i]);
+	retval = UA_ByteString_newMembers(&msg2, UA_calcSizeBinary(obj2, &UA_TYPES[_i]));
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
-	pos = 0; retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].encode(obj2, &msg2, &pos);
+	pos = 0; retval = UA_encodeBinary(obj2, &UA_TYPES[_i], &msg2, &pos);
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// then
-	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == UA_TRUE, "messages differ idx=%d,name=%s", _i, UA_TYPES[_i].name);
+	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == UA_TRUE, "messages differ idx=%d,nodeid=%i", _i, UA_TYPES_IDS[_i]);
 
 	// finally
-	UA_TYPES[_i].delete(obj1);
-	UA_TYPES[_i].delete(obj2);
+	UA_delete(obj1, &UA_TYPES[_i]);
+	UA_delete(obj2, &UA_TYPES[_i]);
 	UA_ByteString_deleteMembers(&msg1);
 	UA_ByteString_deleteMembers(&msg2);
 }
@@ -87,20 +84,20 @@ START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
 	// given
 	UA_ByteString msg1;
 	UA_UInt32 pos;
-	void *obj1 = UA_TYPES[_i].new();
-	UA_ByteString_newMembers(&msg1, UA_TYPES[_i].encodings[0].calcSize(obj1));
-	pos = 0; UA_TYPES[_i].encodings[0].encode(obj1, &msg1, &pos);
-	UA_TYPES[_i].delete(obj1);
+	void *obj1 = UA_new(&UA_TYPES[_i]);
+	UA_ByteString_newMembers(&msg1, UA_calcSizeBinary(obj1, &UA_TYPES[_i]));
+    pos = 0; UA_encodeBinary(obj1, &UA_TYPES[_i], &msg1, &pos);
+	UA_delete(obj1, &UA_TYPES[_i]);
 	// when
-	void *obj2 = UA_TYPES[_i].new();
+	void *obj2 = UA_new(&UA_TYPES[_i]);
 	pos = 0;
 	msg1.length = msg1.length / 2;
 	//fprintf(stderr,"testing %s with half buffer\n",UA_TYPES[_i].name);
-	UA_TYPES[_i].encodings[0].decode(&msg1, &pos, obj2);
+	UA_decodeBinary(&msg1, &pos, obj2, &UA_TYPES[_i]);
 	//then
 	// finally
 	//fprintf(stderr,"delete %s with half buffer\n",UA_TYPES[_i].name);
-	UA_TYPES[_i].delete(obj2);
+	UA_delete(obj2, &UA_TYPES[_i]);
 	UA_ByteString_deleteMembers(&msg1);
 }
 END_TEST
@@ -130,12 +127,12 @@ START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 #endif
 		}
 		UA_UInt32 pos = 0;
-		obj1 = UA_TYPES[_i].new();
-		retval |= UA_TYPES[_i].encodings[0].decode(&msg1, &pos, obj1);
+		obj1 = UA_new(&UA_TYPES[_i]);
+		retval |= UA_decodeBinary(&msg1, &pos, obj1, &UA_TYPES[_i]);
 		//then
-		ck_assert_msg(retval == UA_STATUSCODE_GOOD, "Decoding %s from random buffer", UA_TYPES[_i].name);
+		ck_assert_msg(retval == UA_STATUSCODE_GOOD, "Decoding %d from random buffer", UA_TYPES_IDS[_i]);
 		// finally
-		UA_TYPES[_i].delete(obj1);
+		UA_delete(obj1, &UA_TYPES[_i]);
 	}
 	UA_ByteString_deleteMembers(&msg1);
 }
@@ -164,9 +161,9 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 #endif
 		}
 		UA_UInt32 pos = 0;
-		void *obj1 = UA_TYPES[_i].new();
-		retval |= UA_TYPES[_i].encodings[0].decode(&msg1, &pos, obj1);
-		UA_TYPES[_i].delete(obj1);
+		void *obj1 = UA_new(&UA_TYPES[_i]);
+		retval |= UA_decodeBinary(&msg1, &pos, obj1, &UA_TYPES[_i]);
+		UA_delete(obj1, &UA_TYPES[_i]);
 	}
 
 	// finally
@@ -180,18 +177,17 @@ int main(void) {
 
 	Suite *s  = suite_create("testMemoryHandling");
 	TCase *tc = tcase_create("Empty Objects");
-	tcase_add_loop_test(tc, newAndEmptyObjectShallBeDeleted, UA_BOOLEAN, UA_INVALIDTYPE-1);
+	tcase_add_loop_test(tc, newAndEmptyObjectShallBeDeleted, UA_TYPES_BOOLEAN, UA_TYPES_EVENTNOTIFICATIONLIST);
 	tcase_add_test(tc, arrayCopyShallMakeADeepCopy);
-	tcase_add_loop_test(tc, encodeShallYieldDecode, UA_BOOLEAN, UA_INVALIDTYPE-1);
+	tcase_add_loop_test(tc, encodeShallYieldDecode, UA_TYPES_BOOLEAN, UA_TYPES_EVENTNOTIFICATIONLIST);
 	suite_add_tcase(s, tc);
 	tc = tcase_create("Truncated Buffers");
-	tcase_add_loop_test(tc, decodeShallFailWithTruncatedBufferButSurvive, UA_BOOLEAN, UA_INVALIDTYPE-1);
+	tcase_add_loop_test(tc, decodeShallFailWithTruncatedBufferButSurvive, UA_TYPES_BOOLEAN, UA_TYPES_EVENTNOTIFICATIONLIST);
 	suite_add_tcase(s, tc);
 
 	tc = tcase_create("Fuzzing with Random Buffers");
-	tcase_add_loop_test(tc, decodeScalarBasicTypeFromRandomBufferShallSucceed, UA_BOOLEAN, UA_DOUBLE);
-	tcase_add_loop_test(tc, decodeComplexTypeFromRandomBufferShallSurvive, UA_STRING, UA_DIAGNOSTICINFO);
-	tcase_add_loop_test(tc, decodeComplexTypeFromRandomBufferShallSurvive, UA_IDTYPE, UA_INVALIDTYPE);
+	tcase_add_loop_test(tc, decodeScalarBasicTypeFromRandomBufferShallSucceed, UA_TYPES_BOOLEAN, UA_TYPES_GUID);
+	tcase_add_loop_test(tc, decodeComplexTypeFromRandomBufferShallSurvive, UA_TYPES_NODEID, UA_TYPES_EVENTNOTIFICATIONLIST);
 	suite_add_tcase(s, tc);
 
 	sr = srunner_create(s);