fix unit tests

tests/check_builtin.c

@@ -473,7 +473,7 @@ START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {
 	// given
 	UA_Variant arg;
 	UA_Variant_init(&arg);
-	arg.vt = &UA_.types[UA_INT32];
+	arg.vt = &UA_[UA_INT32];
 #define ARRAY_LEN 8
 	arg.storage.data.arrayLength = ARRAY_LEN;
 	UA_Int32 *data[ARRAY_LEN];
@@ -491,7 +491,7 @@ START_TEST(UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize) {
 	// given
 	UA_Variant arg;
 	UA_Variant_init(&arg);
-	arg.vt = &UA_.types[UA_STRING];
+	arg.vt = &UA_[UA_STRING];
 #define ARRAY_LEN 3
 	arg.storage.data.arrayLength = ARRAY_LEN;
 	UA_String strings[3];
@@ -862,7 +862,7 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	// then
 	ck_assert_int_eq(retval, UA_SUCCESS);
 	ck_assert_int_eq(pos, 5);
-	ck_assert_ptr_eq(dst.vt, &UA_.types[UA_INT32]);
+	ck_assert_ptr_eq(dst.vt, &UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 1);
 	ck_assert_int_eq(*(UA_Int32 *)dst.storage.data.dataPtr, 255);
 	// finally
@@ -884,7 +884,7 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	// then
 	ck_assert_int_eq(retval, UA_SUCCESS);
 	ck_assert_int_eq(pos, 1+4+2*4);
-	ck_assert_ptr_eq(dst.vt, &UA_.types[UA_INT32]);
+	ck_assert_ptr_eq(dst.vt, &UA_[UA_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);
@@ -1307,7 +1307,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
 	src.serverTimestamp    = 80;
 	src.encodingMask       = UA_DATAVALUE_ENCODINGMASK_VARIANT | UA_DATAVALUE_ENCODINGMASK_SERVERTIMESTAMP; //Variant & SourvePicoseconds
 	UA_Variant_init(&src.value);
-	src.value.vt           = &UA_.types[UA_INT32];
+	src.value.vt           = &UA_[UA_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;
@@ -1426,7 +1426,7 @@ START_TEST(UA_Array_copyByteArrayShallWorkOnExample) {
 	testString.length  = 5;
 
 	//when
-	UA_Array_copy((const void *)testString.data, 5, &UA_.types[UA_BYTE], (void **)&dstArray);
+	UA_Array_copy((const void *)testString.data, 5, &UA_[UA_BYTE], (void **)&dstArray);
 	//then
 	for(i = 0;i < size;i++)
 		ck_assert_int_eq(testString.data[i], dstArray[i]);
@@ -1442,14 +1442,14 @@ START_TEST(UA_Array_copyUA_StringShallWorkOnExample) {
 	// given
 	UA_Int32   i, j;
 	UA_String *srcArray;
-	UA_Array_new((void **)&srcArray, 3, &UA_.types[UA_STRING]);
+	UA_Array_new((void **)&srcArray, 3, &UA_[UA_STRING]);
 	UA_String *dstArray;
 
 	UA_String_copycstring("open", &srcArray[0]);
 	UA_String_copycstring("62541", &srcArray[1]);
 	UA_String_copycstring("opc ua", &srcArray[2]);
 	//when
-	UA_Array_copy((const void *)srcArray, 3, &UA_.types[UA_STRING], (void **)&dstArray);
+	UA_Array_copy((const void *)srcArray, 3, &UA_[UA_STRING], (void **)&dstArray);
 	//then
 	for(i = 0;i < 3;i++) {
 		for(j = 0;j < 3;j++)
@@ -1457,8 +1457,8 @@ START_TEST(UA_Array_copyUA_StringShallWorkOnExample) {
 		ck_assert_int_eq(srcArray[i].length, dstArray[i].length);
 	}
 	//finally
-	UA_Array_delete(srcArray, 3, &UA_.types[UA_STRING]);
-	UA_Array_delete(dstArray, 3, &UA_.types[UA_STRING]);
+	UA_Array_delete(srcArray, 3, &UA_[UA_STRING]);
+	UA_Array_delete(dstArray, 3, &UA_[UA_STRING]);
 }
 END_TEST
 
@@ -1675,7 +1675,7 @@ START_TEST(UA_Variant_copyShallWorkOnSingleValueExample) {
 	UA_Variant_init(&copiedValue);
 	UA_alloc((void**)&value.storage.data.dataPtr, sizeof(UA_String));
 	*((UA_String*)value.storage.data.dataPtr) = testString;
-	value.vt = &UA_.types[UA_STRING];
+	value.vt = &UA_[UA_STRING];
 	value.storage.data.arrayLength = 1;
 
 	//when
@@ -1699,7 +1699,7 @@ END_TEST
 START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	// given
 	UA_String *srcArray;
-	UA_Array_new((void **)&srcArray, 3, &UA_.types[UA_STRING]);
+	UA_Array_new((void **)&srcArray, 3, &UA_[UA_STRING]);
 	UA_String_copycstring("__open", &srcArray[0]);
 	UA_String_copycstring("_62541", &srcArray[1]);
 	UA_String_copycstring("opc ua", &srcArray[2]);
@@ -1716,7 +1716,7 @@ START_TEST(UA_Variant_copyShallWorkOn1DArrayExample) {
 	value.storage.data.dataPtr        = (void **)srcArray;
 	value.storage.data.arrayDimensionsLength = 1;
 	value.storage.data.arrayDimensions       = dimensions;
-	value.vt = &UA_.types[UA_STRING];
+	value.vt = &UA_[UA_STRING];
 
 	//when
 	UA_Variant_copy(&value, &copiedValue);
@@ -1745,7 +1745,7 @@ END_TEST
 START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	// given
 	UA_Int32 *srcArray;
-	UA_Array_new((void **)&srcArray, 6, &UA_.types[UA_INT32]);
+	UA_Array_new((void **)&srcArray, 6, &UA_[UA_INT32]);
 	srcArray[0] = 0;
 	srcArray[1] = 1;
 	srcArray[2] = 2;
@@ -1754,7 +1754,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	srcArray[5] = 5;
 
 	UA_Int32 *dimensions;
-	UA_Array_new((void **)&dimensions, 2, &UA_.types[UA_INT32]);
+	UA_Array_new((void **)&dimensions, 2, &UA_[UA_INT32]);
 	UA_Int32  dim1 = 3;
 	UA_Int32  dim2 = 2;
 	dimensions[0] = dim1;
@@ -1768,7 +1768,7 @@ START_TEST(UA_Variant_copyShallWorkOn2DArrayExample) {
 	value.storage.data.dataPtr        = (void **)srcArray;
 	value.storage.data.arrayDimensionsLength = 2;
 	value.storage.data.arrayDimensions       = dimensions;
-	value.vt = &UA_.types[UA_INT32];
+	value.vt = &UA_[UA_INT32];
 
 	//when
 	UA_Variant_copy(&value, &copiedValue);

tests/check_memory.c

@@ -12,11 +12,11 @@ START_TEST(newAndEmptyObjectShallBeDeleted) {
 	UA_Int32 retval;
 	void    *obj;
 	// when
-	retval  = UA_.types[_i].new(&obj);
+	retval  = UA_[_i].new(&obj);
 #ifdef DEBUG //no print functions if not in debug mode
-	UA_.types[_i].print(obj, stdout);
+	UA_[_i].print(obj, stdout);
 #endif
-	UA_.types[_i].delete(obj);
+	UA_[_i].delete(obj);
 	// then
 	ck_assert_int_eq(retval, UA_SUCCESS);
 }
@@ -30,7 +30,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, &UA_[UA_STRING], (void **)&a2);
 	// then
 	ck_assert_int_eq(retval, UA_SUCCESS);
 	ck_assert_int_eq(a1[0].length, 1);
@@ -46,7 +46,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_[UA_STRING]);
 }
 END_TEST
 
@@ -56,31 +56,31 @@ START_TEST(encodeShallYieldDecode) {
 	UA_ByteString msg1, msg2;
 	UA_Int32      retval;
 	UA_UInt32     pos = 0;
-	retval = UA_.types[_i].new(&obj1);
-	UA_ByteString_newMembers(&msg1, UA_.types[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
-	retval |= UA_.types[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
+	retval = UA_[_i].new(&obj1);
+	UA_ByteString_newMembers(&msg1, UA_[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
+	retval |= UA_[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
 	if(retval != UA_SUCCESS) {
-		// this happens, e.g. when we encode a variant (with UA_.types[UA_INVALIDTYPE] in the vtable)
-		UA_.types[_i].delete(obj1);
+		// this happens, e.g. when we encode a variant (with UA_[UA_INVALIDTYPE] in the vtable)
+		UA_[_i].delete(obj1);
 		UA_ByteString_deleteMembers(&msg1);
 		return;	
 	}
 
 	// when
-	UA_.types[_i].new(&obj2);
-	pos = 0; retval = UA_.types[_i].encodings[UA_ENCODING_BINARY].decode(&msg1, &pos, obj2);
-	ck_assert_msg(retval == UA_SUCCESS, "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));
+	UA_[_i].new(&obj2);
+	pos = 0; retval = UA_[_i].encodings[UA_ENCODING_BINARY].decode(&msg1, &pos, obj2);
+	ck_assert_msg(retval == UA_SUCCESS, "messages differ idx=%d,name=%s", _i, UA_[_i].name);
+	retval = UA_ByteString_newMembers(&msg2, UA_[_i].encodings[UA_ENCODING_BINARY].calcSize(obj2));
 	ck_assert_int_eq(retval, UA_SUCCESS);
-	pos = 0; retval = UA_.types[_i].encodings[UA_ENCODING_BINARY].encode(obj2, &msg2, &pos);
+	pos = 0; retval = UA_[_i].encodings[UA_ENCODING_BINARY].encode(obj2, &msg2, &pos);
 	ck_assert_int_eq(retval, UA_SUCCESS);
 
 	// then
-	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == 0, "messages differ idx=%d,name=%s", _i, UA_.types[_i].name);
+	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == 0, "messages differ idx=%d,name=%s", _i, UA_[_i].name);
 
 	// finally
-	UA_.types[_i].delete(obj1);
-	UA_.types[_i].delete(obj2);
+	UA_[_i].delete(obj1);
+	UA_[_i].delete(obj2);
 	UA_ByteString_deleteMembers(&msg1);
 	UA_ByteString_deleteMembers(&msg2);
 }
@@ -91,20 +91,20 @@ START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
 	void *obj1 = UA_NULL, *obj2 = UA_NULL;
 	UA_ByteString msg1;
 	UA_UInt32 pos;
-	UA_.types[_i].new(&obj1);
-	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);
+	UA_[_i].new(&obj1);
+	UA_ByteString_newMembers(&msg1, UA_[_i].encodings[0].calcSize(obj1));
+	pos = 0; UA_[_i].encodings[0].encode(obj1, &msg1, &pos);
+	UA_[_i].delete(obj1);
 	// when
-	UA_.types[_i].new(&obj2);
+	UA_[_i].new(&obj2);
 	pos = 0;
 	msg1.length = msg1.length / 2;
 	//fprintf(stderr,"testing %s with half buffer\n",UA_[_i].name);
-	UA_.types[_i].encodings[0].decode(&msg1, &pos, obj2);
+	UA_[_i].encodings[0].decode(&msg1, &pos, obj2);
 	//then
 	// finally
 	//fprintf(stderr,"delete %s with half buffer\n",UA_[_i].name);
-	UA_.types[_i].delete(obj2);
+	UA_[_i].delete(obj2);
 	UA_ByteString_deleteMembers(&msg1);
 }
 END_TEST
@@ -132,12 +132,12 @@ START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 #endif
 		}
 		UA_UInt32 pos = 0;
-		retval |= UA_.types[_i].new(&obj1);
-		retval |= UA_.types[_i].encodings[0].decode(&msg1, &pos, obj1);
+		retval |= UA_[_i].new(&obj1);
+		retval |= UA_[_i].encodings[0].decode(&msg1, &pos, obj1);
 		//then
-		ck_assert_msg(retval == UA_SUCCESS, "Decoding %s from random buffer", UA_.types[_i].name);
+		ck_assert_msg(retval == UA_SUCCESS, "Decoding %s from random buffer", UA_[_i].name);
 		// finally
-		UA_.types[_i].delete(obj1);
+		UA_[_i].delete(obj1);
 	}
 	UA_ByteString_deleteMembers(&msg1);
 }
@@ -167,13 +167,13 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 #endif
 		}
 		UA_UInt32 pos = 0;
-		retval |= UA_.types[_i].new(&obj1);
-		retval |= UA_.types[_i].encodings[0].decode(&msg1, &pos, obj1);
+		retval |= UA_[_i].new(&obj1);
+		retval |= UA_[_i].encodings[0].decode(&msg1, &pos, obj1);
 
 		//this is allowed to fail and return UA_ERROR
-		//ck_assert_msg(retval == UA_SUCCESS, "Decoding %s from random buffer", UA_.types[_i].name);
+		//ck_assert_msg(retval == UA_SUCCESS, "Decoding %s from random buffer", UA_[_i].name);
 		
-		UA_.types[_i].delete(obj1);
+		UA_[_i].delete(obj1);
 	}
 
 	// finally