Fusion of check_calcSize.c , check_decode , check_encode in

check_builtin

tests/check_builtin.c

@@ -186,6 +186,14 @@ START_TEST(UA_NodeId_calcSizeWithNullArgumentShallReturnStorageSize)
 	ck_assert_int_eq(storageSize, sizeof(UA_NodeId));
 }
 END_TEST
+START_TEST(UA_ExpandedNodeId_calcSizeShallWorkOnExample)
+{
+	//ToDo: Function needs to be filled
+	UA_Int32 valreal = 300;
+	UA_Int32 valcalc = 0;
+	ck_assert_int_eq(valcalc,valreal);
+}
+END_TEST
 START_TEST(UA_ExpandedNodeId_calcSizeWithNullArgumentShallReturnStorageSize)
 {
 	// given
@@ -236,6 +244,48 @@ START_TEST(UA_ExtensionObject_calcSizeWithNullArgumentShallReturnStorageSize)
 	ck_assert_int_eq(storageSize, sizeof(UA_ExtensionObject));
 }
 END_TEST
+START_TEST(UA_ExtensionObject_calcSizeShallWorkOnExample)
+{
+	// given
+	UA_Byte data[3] = {1,2,3};
+	UA_ExtensionObject extensionObject;
+
+	// empty ExtensionObject, handcoded
+	// when
+	extensionObject.typeId.encodingByte = UA_NODEIDTYPE_TWOBYTE;
+	extensionObject.typeId.identifier.numeric = 0;
+	extensionObject.encoding = UA_EXTENSIONOBJECT_ENCODINGMASKTYPE_NOBODYISENCODED;
+	// then
+	ck_assert_int_eq(UA_ExtensionObject_calcSize(&extensionObject), 1 + 1 + 1);
+
+	// ExtensionObject with ByteString-Body
+	// when
+	extensionObject.encoding = UA_EXTENSIONOBJECT_ENCODINGMASKTYPE_BODYISBYTESTRING;
+	extensionObject.body.data = data;
+	extensionObject.body.length = 3;
+	// then
+	ck_assert_int_eq(UA_ExtensionObject_calcSize(&extensionObject), 3 + 4 + 3);
+}
+END_TEST
+START_TEST(UA_DataValue_calcSizeShallWorkOnExample)
+{
+	// given
+	UA_DataValue dataValue;
+	dataValue.encodingMask = UA_DATAVALUE_STATUSCODE |  UA_DATAVALUE_SOURCETIMESTAMP |  UA_DATAVALUE_SOURCEPICOSECONDS;
+	dataValue.status = 12;
+	UA_DateTime dateTime;
+	dateTime = 80;
+	dataValue.sourceTimestamp = dateTime;
+	UA_DateTime sourceTime;
+	sourceTime = 214;
+	dataValue.sourcePicoseconds = sourceTime;
+	int size = 0;
+	// when
+	size = UA_DataValue_calcSize(&dataValue);
+	// then
+	ck_assert_int_eq(size, 21);
+}
+END_TEST
 START_TEST(UA_DataValue_calcSizeWithNullArgumentShallReturnStorageSize)
 {
 	// given
@@ -256,6 +306,21 @@ START_TEST(UA_Variant_calcSizeWithNullArgumentShallReturnStorageSize)
 	ck_assert_int_eq(storageSize, sizeof(UA_Variant));
 }
 END_TEST
+START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample)
+{
+	// given
+	UA_DiagnosticInfo diagnosticInfo;
+	diagnosticInfo.encodingMask = 0x01 | 0x02 | 0x04 | 0x08 | 0x10;
+	diagnosticInfo.symbolicId = 30;
+	diagnosticInfo.namespaceUri = 25;
+	diagnosticInfo.localizedText = 22;
+	UA_Byte additionalInfoData = 'd';
+	diagnosticInfo.additionalInfo.data = &additionalInfoData;//"OPCUA";
+	diagnosticInfo.additionalInfo.length = 5;
+	// when & then
+	ck_assert_int_eq(UA_DiagnosticInfo_calcSize(&diagnosticInfo),26);
+}
+END_TEST
 START_TEST(UA_DiagnosticInfo_calcSizeWithNullArgumentShallReturnStorageSize)
 {
 	// given
@@ -646,6 +711,41 @@ START_TEST(UA_UInt32_decodeShallNotRespectSign)
 	ck_assert_uint_eq(val_00_80, (UA_UInt32) (0x01 << 31));
 }
 END_TEST
+START_TEST(UA_UInt64_decodeShallNotRespectSign)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_UInt64 expectedVal = 0xFF;
+	expectedVal = expectedVal << 56;
+	UA_Byte mem[8] = {00,00,00,00,0x00,0x00,0x00,0xFF};
+	rawMessage.data = mem;
+	rawMessage.length = 8;
+	UA_Int32 p = 0;
+	UA_UInt64 val;
+	// when
+	UA_UInt64_decode(rawMessage.data, &p, &val);
+	// then
+	ck_assert_uint_eq(val, expectedVal);
+}
+END_TEST
+START_TEST(UA_Int64_decodeShallRespectSign)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_Int64 expectedVal = 0xFF;
+	expectedVal = expectedVal << 56;
+	UA_Byte mem[8] = {00,00,00,00,0x00,0x00,0x00,0xFF};
+	rawMessage.data = mem;
+	rawMessage.length = 8;
+
+	UA_Int32 p = 0;
+	UA_Int64 val;
+	// when
+	UA_Int64_decode(rawMessage.data, &p, &val);
+	//then
+	ck_assert_uint_eq(val, expectedVal);
+}
+END_TEST
 START_TEST(UA_Float_decodeShallWorkOnExample)
 {
 	// given
@@ -709,7 +809,26 @@ START_TEST(UA_Double_decodeShallGiveMinusTwo)
 	ck_assert(dst > -2.00000000001);
 }
 END_TEST
-
+START_TEST(UA_ByteString_decodeShallAllocateMemoryAndCopyByteString)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_Int32 position = 0;
+	UA_Byte* mem = (UA_Byte*) malloc(sizeof(UA_Byte));
+	UA_Byte val;
+	rawMessage.data = mem;
+	rawMessage.length = 1;
+	mem[0] = 0x08;
+	position = 0;
+	// when
+	UA_Byte_decode(rawMessage.data, &position, &val);
+	// then
+	ck_assert_int_eq(val, 0x08);
+	ck_assert_int_eq(position, 1);
+	// finally
+	free(mem);
+}
+END_TEST
 START_TEST(UA_String_decodeShallAllocateMemoryAndCopyString)
 {
 	// given
@@ -866,27 +985,31 @@ START_TEST(UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem)
 }
 END_TEST
 
-START_TEST(UA_Byte_encode_test)
+
+START_TEST(UA_Byte_encodeShallWorkOnExample)
 {
+	// given
 	UA_Byte src;
 	UA_Byte dst[2] = { 0x00, 0xFF };
 	UA_Int32 retval, pos = 0;
-
+	// when
 	ck_assert_uint_eq(dst[1], 0xFF);
-
 	src = 8;
 	retval = UA_Byte_encode(&src, &pos, dst);
-
+	// then
 	ck_assert_uint_eq(dst[0], 0x08);
 	ck_assert_uint_eq(dst[1], 0xFF);
 	ck_assert_int_eq(pos, 1);
 	ck_assert_int_eq(retval, UA_SUCCESS);
 
+	// Test2
+	// given
 	src = 0xFF;
 	dst[1] = 0x00;
 	pos = 0;
+	// when
 	retval = UA_Byte_encode(&src, &pos, dst);
-
+	// then
 	ck_assert_int_eq(dst[0], 0xFF);
 	ck_assert_int_eq(dst[1], 0x00);
 	ck_assert_int_eq(pos, 1);
@@ -894,6 +1017,277 @@ START_TEST(UA_Byte_encode_test)
 
 }
 END_TEST
+START_TEST(UA_ByteString_encodeShallWorkOnExample)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_Int32 position = 0;
+	UA_Byte *mem = malloc(sizeof(UA_Byte));
+	rawMessage.data = mem;
+	UA_Byte testByte = 0x08;
+	rawMessage.length = 1;
+	position = 0;
+	// when
+	UA_Byte_encode(&(testByte), &position, rawMessage.data);
+	// then
+	ck_assert_int_eq(rawMessage.data[0], 0x08);
+	ck_assert_int_eq(rawMessage.length, 1);
+	ck_assert_int_eq(position, 1);
+	// finally
+	free(mem);
+}
+END_TEST
+START_TEST(UA_Int16_encodeShallWorkOnExample)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_Int32 position = 0;
+	UA_Byte *mem = malloc(sizeof(UA_UInt16));
+	rawMessage.data = mem;
+	UA_UInt16 testUInt16 = 1;
+	rawMessage.length = 2;
+	position = 0;
+	// when
+	UA_UInt16_encode(&testUInt16, &position, rawMessage.data);
+	// then
+	ck_assert_int_eq(position, 2);
+	UA_Int32 p = 0;
+	UA_UInt16 val;
+	UA_UInt16_decode(rawMessage.data, &p, &val);
+	ck_assert_int_eq(val,testUInt16);
+	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
+	// finally
+	free(mem);
+}
+END_TEST
+START_TEST(UA_UInt16_encodeShallWorkOnExample)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_Int32 position = 0;
+	UA_Byte *mem = (UA_Byte*) malloc(sizeof(UA_UInt16));
+	rawMessage.data = mem;
+	UA_UInt16 testUInt16 = 1;
+	rawMessage.length = 2;
+	position = 0;
+	// when
+	UA_UInt16_encode(&testUInt16, &position, rawMessage.data);
+	// then
+	ck_assert_int_eq(position, 2);
+	UA_Int32 p = 0;
+	UA_UInt16 val;
+	UA_UInt16_decode(rawMessage.data, &p, &val);
+	ck_assert_int_eq(val,testUInt16);
+	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
+	// finally
+	free(mem);
+}
+END_TEST
+START_TEST(UA_UInt32_encodeShallWorkOnExample)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_UInt32 value = 0x0101FF00;
+	rawMessage.data = (UA_Byte*) malloc(2 * sizeof(UA_UInt32));
+	rawMessage.length = 8;
+	UA_Int32 p = 4;
+	// when
+	UA_UInt32_encode(&value,&p,rawMessage.data);
+	// then
+	ck_assert_uint_eq(rawMessage.data[4],0x00);
+	ck_assert_uint_eq(rawMessage.data[5],0xFF);
+	ck_assert_uint_eq(rawMessage.data[6],0x01);
+	ck_assert_uint_eq(rawMessage.data[7],0x01);
+	ck_assert_int_eq(p,8);
+	// finally
+	free(rawMessage.data);
+}
+END_TEST
+START_TEST(UA_Int32_encodeShallEncodeLittleEndian)
+{
+	// given
+	UA_Int32 value = 0x01020304;
+	UA_Byte  buf[4];
+	UA_Int32 p = 0;
+	// when
+	UA_Int32_encode(&value,&p,buf);
+	// then
+	ck_assert_int_eq(p,4);
+	ck_assert_uint_eq(buf[0],0x04);
+	ck_assert_uint_eq(buf[1],0x03);
+	ck_assert_uint_eq(buf[2],0x02);
+	ck_assert_uint_eq(buf[3],0x01);
+}
+END_TEST
+START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian)
+{
+	// given
+	UA_Int32 value = -1;
+	UA_Byte  buf[4];
+	UA_Int32 p = 0;
+	// when
+	UA_Int32_encode(&value,&p,buf);
+	// then
+	ck_assert_int_eq(p,4);
+	ck_assert_uint_eq(buf[0],0xFF);
+	ck_assert_uint_eq(buf[1],0xFF);
+	ck_assert_uint_eq(buf[2],0xFF);
+	ck_assert_uint_eq(buf[3],0xFF);
+}
+END_TEST
+START_TEST(UA_UInt64_encodeShallWorkOnExample)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_UInt64 value = 0x0101FF00FF00FF00;
+	rawMessage.data = (UA_Byte*) malloc(sizeof(UA_UInt64));
+	rawMessage.length = 8;
+	UA_Int32 p = 0;
+	// when
+	UA_UInt64_encode(&value, &p,rawMessage.data);
+	// then
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[0],0x00);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[1],0xFF);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[2],0x00);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[3],0xFF);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[4],0x00);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[5],0xFF);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[6],0x01);
+	ck_assert_uint_eq((UA_Byte)rawMessage.data[7],0x01);
+	// finally
+	free(rawMessage.data);
+}
+END_TEST
+START_TEST(UA_Int64_encodeShallWorkOnExample)
+{
+	// given
+	UA_ByteString rawMessage;
+	UA_UInt64 value = 0x0101FF00FF00FF00;
+	rawMessage.data = (UA_Byte*) malloc(sizeof(UA_UInt64));
+	rawMessage.length = 8;
+	UA_Int32 p = 0;
+	// when
+	UA_UInt64_encode(&value, &p,rawMessage.data);
+	// then
+	ck_assert_uint_eq(rawMessage.data[0],0x00);
+	ck_assert_uint_eq(rawMessage.data[1],0xFF);
+	ck_assert_uint_eq(rawMessage.data[2],0x00);
+	ck_assert_uint_eq(rawMessage.data[3],0xFF);
+	ck_assert_uint_eq(rawMessage.data[4],0x00);
+	ck_assert_uint_eq(rawMessage.data[5],0xFF);
+	ck_assert_uint_eq(rawMessage.data[6],0x01);
+	ck_assert_uint_eq(rawMessage.data[7],0x01);
+	// finally
+	free(rawMessage.data);
+}
+END_TEST
+START_TEST(UA_Float_encodeShallWorkOnExample)
+{
+	// given
+	UA_Float value = -6.5;
+	UA_Int32 pos = 0;
+	UA_Byte* buf = (UA_Byte*)malloc(sizeof(UA_Float));
+	// when
+	UA_Float_encode(&value,&pos,buf);
+	// then
+	ck_assert_uint_eq(buf[2],0xD0);
+	ck_assert_uint_eq(buf[3],0xC0);
+	// finally
+	free(buf);
+}
+END_TEST
+/*START_TEST(encodeDouble_test)
+{
+	UA_Double value = -6.5;
+	UA_Int32 pos = 0;
+	UA_Byte* buf = (char*)malloc(sizeof(UA_Double));
+
+	UA_Double_encode(&value,&pos,buf);
+
+	ck_assert_uint_eq(buf[6],0xD0);
+	ck_assert_uint_eq(buf[7],0xC0);
+	free(buf);
+}
+END_TEST*/
+START_TEST(UA_String_encodeShallWorkOnExample)
+{
+	// given
+	UA_Int32 pos = 0;
+	UA_String string;
+	UA_Int32 l = 11;
+	UA_Byte mem[11] = "ACPLT OPCUA";
+	UA_Byte *dstBuf = (UA_Byte*) malloc(sizeof(UA_Int32)+l);
+	string.data =  mem;
+	string.length = 11;
+	// when
+	UA_String_encode(&string, &pos, dstBuf);
+	// then
+	ck_assert_int_eq(dstBuf[0],11);
+	ck_assert_int_eq(dstBuf[0+sizeof(UA_Int32)],'A');
+	// finally
+	free(dstBuf);
+}
+END_TEST
+START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant)
+{
+	// given
+	UA_DataValue dataValue;
+	UA_Int32 pos = 0;
+	UA_Byte* buf = (UA_Byte*) malloc(15);
+	UA_DateTime dateTime;
+	dateTime = 80;
+	dataValue.serverTimestamp = dateTime;
+	dataValue.encodingMask = UA_DATAVALUE_SERVERTIMPSTAMP; //Only the sourcePicoseconds
+	// when
+	UA_DataValue_encode(&dataValue, &pos, buf);
+	//then
+	ck_assert_int_eq(pos, 9);// represents the length
+	ck_assert_uint_eq(buf[0], 0x08); // encodingMask
+	ck_assert_uint_eq(buf[1], 80); // 8 Byte serverTimestamp
+	ck_assert_uint_eq(buf[2], 0);
+	ck_assert_uint_eq(buf[3], 0);
+	ck_assert_uint_eq(buf[4], 0);
+	ck_assert_uint_eq(buf[5], 0);
+	ck_assert_uint_eq(buf[6], 0);
+	ck_assert_uint_eq(buf[7], 0);
+	ck_assert_uint_eq(buf[8], 0);
+	// finally
+	free(buf);
+}
+END_TEST
+START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant)
+{
+	// given
+	UA_DataValue dataValue;
+	UA_Int32 pos = 0, retval;
+	UA_Byte* buf = (UA_Byte*) malloc(15);
+	dataValue.encodingMask = UA_DATAVALUE_VARIANT | UA_DATAVALUE_SERVERTIMPSTAMP; //Variant & SourvePicoseconds
+	dataValue.value.vt = &UA_[UA_INT32];
+	dataValue.value.arrayLength = 0;
+	dataValue.value.encodingMask = UA_INT32_NS0;
+	UA_DateTime serverTime = 80;
+	dataValue.serverTimestamp = serverTime;
+	UA_Int32 data = 45;
+	UA_Int32* pdata = &data;
+	dataValue.value.data = (void**) &pdata;
+	pos = 0;
+	// when
+	retval = UA_DataValue_encode(&dataValue, &pos, buf);
+	// then
+	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(pos, 1+(1+4)+8);// represents the length
+	ck_assert_uint_eq(buf[0], 0x08 | 0x01); // encodingMask
+	ck_assert_uint_eq(buf[1], 0x06); // Variant's Encoding Mask - INT32
+	ck_assert_uint_eq(buf[2], 45);  // the single value
+	ck_assert_uint_eq(buf[3], 0);
+	ck_assert_uint_eq(buf[4], 0);
+	ck_assert_uint_eq(buf[5], 0);
+	ck_assert_uint_eq(buf[6], 80);  // the server timestamp
+	ck_assert_uint_eq(buf[7], 0);
+	// finally
+	free(buf);
+}
+END_TEST
 
 Suite *testSuite_builtin(void)
 {
@@ -921,9 +1315,12 @@ Suite *testSuite_builtin(void)
 	tcase_add_test(tc_calcSize, UA_StatusCode_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_QualifiedName_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_LocalizedText_calcSizeWithNullArgumentShallReturnStorageSize);
+	tcase_add_test(tc_calcSize, UA_ExtensionObject_calcSizeShallWorkOnExample);
 	tcase_add_test(tc_calcSize, UA_ExtensionObject_calcSizeWithNullArgumentShallReturnStorageSize);
+	tcase_add_test(tc_calcSize, UA_DataValue_calcSizeShallWorkOnExample);
 	tcase_add_test(tc_calcSize, UA_DataValue_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_Variant_calcSizeWithNullArgumentShallReturnStorageSize);
+	tcase_add_test(tc_calcSize, UA_DiagnosticInfo_calcSizeShallWorkOnExample);
 	tcase_add_test(tc_calcSize, UA_DiagnosticInfo_calcSizeWithNullArgumentShallReturnStorageSize);
 	tcase_add_test(tc_calcSize, UA_String_calcSizeShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNegativLengthShallReturnEncodingSize);
@@ -935,6 +1332,7 @@ Suite *testSuite_builtin(void)
 	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingStringShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingStringNegativLengthShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingStringZeroLengthShallReturnEncodingSize);
+	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeShallWorkOnExample);
 	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeEncodingStringAndServerIndexShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeEncodingStringAndNamespaceUriShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_Guid_calcSizeShallReturnEncodingSize);
@@ -945,7 +1343,6 @@ Suite *testSuite_builtin(void)
 	tcase_add_test(tc_calcSize, UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize);
 	tcase_add_test(tc_calcSize, UA_Variant_calcSizeVariableSizeArrayWithNullPtrWillReturnWrongButLargeEnoughEncodingSize);
-	tcase_add_test(tc_calcSize, UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem);
 	suite_add_tcase(s,tc_calcSize);
 
 
@@ -959,10 +1356,13 @@ Suite *testSuite_builtin(void)
 	tcase_add_test(tc_decode, UA_Int32_decodeShallAssumeLittleEndian);
 	tcase_add_test(tc_decode, UA_Int32_decodeShallRespectSign);
 	tcase_add_test(tc_decode, UA_UInt32_decodeShallNotRespectSign);
+	tcase_add_test(tc_decode, UA_UInt64_decodeShallNotRespectSign);
+	tcase_add_test(tc_decode, UA_Int64_decodeShallRespectSign);
 	tcase_add_test(tc_decode, UA_Float_decodeShallWorkOnExample);
 	tcase_add_test(tc_decode, UA_Double_decodeShallGiveOne);
 	tcase_add_test(tc_decode, UA_Double_decodeShallGiveZero);
 	tcase_add_test(tc_decode, UA_Double_decodeShallGiveMinusTwo);
+	tcase_add_test(tc_decode, UA_ByteString_decodeShallAllocateMemoryAndCopyByteString);
 	tcase_add_test(tc_decode, UA_String_decodeShallAllocateMemoryAndCopyString);
 	tcase_add_test(tc_decode, UA_String_decodeWithNegativeSizeShallNotAllocateMemoryAndNullPtr);
 	tcase_add_test(tc_decode, UA_String_decodeWithZeroSizeShallNotAllocateMemoryAndNullPtr);
@@ -971,8 +1371,27 @@ Suite *testSuite_builtin(void)
 	tcase_add_test(tc_decode, UA_NodeId_decodeStringShallAllocateMemory);
 	tcase_add_test(tc_decode, UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArray);
 	tcase_add_test(tc_decode, UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray);
+	tcase_add_test(tc_decode, UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem);
 	suite_add_tcase(s,tc_decode);
 
+
+
+	TCase *tc_encode = tcase_create("encode");
+	tcase_add_test(tc_encode, UA_Byte_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_ByteString_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_Int16_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_UInt16_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_UInt32_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_Int32_encodeShallEncodeLittleEndian);
+	tcase_add_test(tc_encode, UA_Int32_encodeNegativeShallEncodeLittleEndian);
+	tcase_add_test(tc_encode, UA_UInt64_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_Int64_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_Float_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_String_encodeShallWorkOnExample);
+	tcase_add_test(tc_encode, UA_DataValue_encodeShallWorkOnExampleWithoutVariant);
+	tcase_add_test(tc_encode, UA_DataValue_encodeShallWorkOnExampleWithVariant);
+	suite_add_tcase(s,tc_encode);
+
 	return s;
 }
 

tests/check_calcSize.c

@@ -16,7 +16,7 @@
 #include "check.h"
 
 
-START_TEST(diagnosticInfo_calcSize_test)
+/*START_TEST(diagnosticInfo_calcSize_test)
 {
 
 	UA_Int32 valreal = 0;
@@ -54,7 +54,7 @@ START_TEST(extensionObject_calcSize_test)
 	extensionObject.body.length = 3;
 	ck_assert_int_eq(UA_ExtensionObject_calcSize(&extensionObject), 3 + 4 + 3);
 }
-END_TEST
+END_TEST*/
 
 START_TEST(responseHeader_calcSize_test)
 {
@@ -86,8 +86,7 @@ START_TEST(responseHeader_calcSize_test)
 	ck_assert_int_eq(UA_ResponseHeader_calcSize(&responseHeader),16+1+4+3);
 }
 END_TEST
-
-//ToDo: Function needs to be filled
+/*//ToDo: Function needs to be filled
 START_TEST(expandedNodeId_calcSize_test)
 {
 	UA_Int32 valreal = 300;
@@ -112,9 +111,9 @@ START_TEST(DataValue_calcSize_test)
 
 	ck_assert_int_eq(size, 21);
 }
-END_TEST
+END_TEST*/
 
-Suite* testSuite_diagnosticInfo_calcSize()
+/*Suite* testSuite_diagnosticInfo_calcSize()
 {
 	Suite *s = suite_create("diagnosticInfo_calcSize");
 	TCase *tc_core = tcase_create("Core");
@@ -129,7 +128,7 @@ Suite* testSuite_extensionObject_calcSize()
 	tcase_add_test(tc_core, extensionObject_calcSize_test);
 	suite_add_tcase(s,tc_core);
 	return s;
-}
+}*/
 Suite* testSuite_responseHeader_calcSize()
 {
 	Suite *s = suite_create("responseHeader_calcSize");
@@ -138,7 +137,7 @@ Suite* testSuite_responseHeader_calcSize()
 	suite_add_tcase(s,tc_core);
 	return s;
 }
-Suite* testSuite_dataValue_calcSize(void)
+/*Suite* testSuite_dataValue_calcSize(void)
 {
 	Suite *s = suite_create("dataValue_calcSize");
 	TCase *tc_core = tcase_create("Core");
@@ -153,13 +152,15 @@ Suite* testSuite_expandedNodeId_calcSize(void)
 	tcase_add_test(tc_core,expandedNodeId_calcSize_test);
 	suite_add_tcase(s,tc_core);
 	return s;
-}
+}*/
 
 int main (void)
 {
 	int number_failed = 0;
-
-	Suite *s = testSuite_diagnosticInfo_calcSize();
+	Suite *s;
+	SRunner *sr;
+/*
+	s = testSuite_diagnosticInfo_calcSize();
 	SRunner *sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
@@ -171,11 +172,13 @@ int main (void)
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
+*/
 	s = testSuite_responseHeader_calcSize();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
+/*
 
 	s = testSuite_expandedNodeId_calcSize();
 	sr = srunner_create(s);
@@ -200,6 +203,7 @@ int main (void)
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
+*/
 
 	/* <TESTSUITE_TEMPLATE>
 	s =  <TESTSUITENAME>;

tests/check_decode.c

@@ -15,7 +15,7 @@
 #include "ua_transportLayer.h"
 #include "check.h"
 
-START_TEST(decodeByte_test)
+/*START_TEST(decodeByte_test)
 {
 	UA_ByteString rawMessage;
 	UA_Int32 position = 0;
@@ -104,8 +104,8 @@ START_TEST(decodeUInt16_test)
 	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
 
 }
-END_TEST
-START_TEST(decodeUInt32_test)
+END_TEST*/
+/*START_TEST(decodeUInt32_test)
 {
 	UA_ByteString rawMessage;
 	//EncodeUInt16
@@ -137,8 +137,8 @@ START_TEST(decodeInt32_test)
 	UA_Int32_decode(rawMessage.data, &p, &val);
 	ck_assert_int_eq(val,1000000000);
 }
-END_TEST
-START_TEST(decodeUInt64_test)
+END_TEST*/
+/*START_TEST(decodeUInt64_test)
 {
 	UA_ByteString rawMessage;
 	UA_UInt64 expectedVal = 0xFF;
@@ -170,8 +170,8 @@ START_TEST(decodeInt64_test)
 	UA_Int64_decode(rawMessage.data, &p, &val);
 	ck_assert_uint_eq(val, expectedVal);
 }
-END_TEST
-START_TEST(decodeFloat_test)
+END_TEST*/
+/*START_TEST(decodeFloat_test)
 {
 	UA_Int32 pos = 0;
 	UA_Byte buf[4] = {0x00,0x00,0xD0,0xC0};
@@ -205,8 +205,8 @@ START_TEST(decodeUAString_test)
 
 	UA_String_deleteMembers(&string);
 }
-END_TEST
-
+END_TEST*/
+/*
 Suite *testSuite_decodeByte(void)
 {
 	Suite *s = suite_create("encodeByte_test");
@@ -287,12 +287,13 @@ Suite * testSuite_decodeUAString(void)
 	tcase_add_test(tc_core, decodeUAString_test);
 	suite_add_tcase(s,tc_core);
 	return s;
-}
+}*/
 
 int main (void)
 {
 	int number_failed = 0;
 
+/*
 	Suite *s = testSuite_decodeByte();
 	SRunner *sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
@@ -340,6 +341,7 @@ int main (void)
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
+*/
 
 
 	/* <TESTSUITE_TEMPLATE>

tests/check_encode.c

@@ -16,7 +16,7 @@
 #include "check.h"
 
 
-START_TEST(encodeByte_test)
+/*START_TEST(encodeByte_test)
 {
 	UA_ByteString rawMessage;
 	UA_Int32 position = 0;
@@ -201,7 +201,7 @@ START_TEST(encodeFloat_test)
 	free(buf);
 }
 END_TEST
-/*START_TEST(encodeDouble_test)
+START_TEST(encodeDouble_test)
 {
 	UA_Double value = -6.5;
 	UA_Int32 pos = 0;
@@ -213,7 +213,7 @@ END_TEST
 	ck_assert_uint_eq(buf[7],0xC0);
 	free(buf);
 }
-END_TEST*/
+END_TEST
 START_TEST(encodeUAString_test)
 {
 
@@ -282,7 +282,8 @@ START_TEST(encodeDataValue_test)
 
 	free(buf);
 }
-END_TEST
+END_TEST*/
+/*
 
 
 Suite *testSuite_encodeByte(void)
@@ -350,14 +351,14 @@ Suite *testSuite_encodeFloat(void)
 	suite_add_tcase(s,tc_core);
 	return s;
 }
-/*Suite *testSuite_encodeDouble(void)
+Suite *testSuite_encodeDouble(void)
 {
 	Suite *s = suite_create("encodeDouble_test");
 	TCase *tc_core = tcase_create("Core");
 	tcase_add_test(tc_core, encodeDouble_test);
 	suite_add_tcase(s,tc_core);
 	return s;
-}*/
+}
 Suite * testSuite_encodeUAString(void)
 {
 	Suite *s = suite_create("encodeUAString_test");
@@ -374,12 +375,14 @@ Suite* testSuite_encodeDataValue()
 	suite_add_tcase(s,tc_core);
 	return s;
 }
+*/
 
 
 int main (void)
 {
 	int number_failed = 0;
 
+/*
 	Suite *s = testSuite_encodeByte();
 	SRunner *sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
@@ -428,11 +431,11 @@ int main (void)
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-/*	s = testSuite_encodeDouble();
+	s = testSuite_encodeDouble();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);*/
+	srunner_free(sr);
 
 	s = testSuite_encodeUAString();
 	sr = srunner_create(s);
@@ -445,6 +448,7 @@ int main (void)
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
+*/
 
 	/* <TESTSUITE_TEMPLATE>
 	s =  <TESTSUITENAME>;