merged

.travis.yml

@@ -1,6 +1,4 @@
 language: c
-notifications:
-  email: true
 before_install:
  - sudo apt-get update -qq
  - sudo apt-get install -qq build-essential subversion git autoconf libtool texinfo python-lxml valgrind

src/ua_basictypes.c

@@ -729,8 +729,8 @@ UA_TYPE_END_XXCODEBINARY
 UA_Int32 UA_NodeId_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_NodeId *dst) {
 	int retval = UA_SUCCESS;
 	// temporary variables to overcome decoder's non-endian-saveness for datatypes
-	UA_Byte   dstByte;
-	UA_UInt16 dstUInt16;
+	UA_Byte   dstByte = 0;
+	UA_UInt16 dstUInt16 = 0;
 
 	retval |= UA_Byte_decodeBinary(src,pos,&(dst->encodingByte));
 	switch (dst->encodingByte & UA_NODEIDTYPE_MASK) {

tests/Makefile.am

@@ -3,7 +3,7 @@ TESTS=
 UNIT_TESTS=
 check_PROGRAMS=
 
-UNIT_TESTS += check_stack check_list check_indexedList check_builtin check_namespace check_encode check_decode check_create check_delete check_memory
+UNIT_TESTS += check_stack check_list check_indexedList check_builtin check_namespace check_memory
 TESTS += $(UNIT_TESTS)
 check_PROGRAMS += $(UNIT_TESTS)
 

tests/check_builtin.c

@@ -1042,258 +1042,390 @@ START_TEST(UA_Byte_encode_test)
 
 }
 END_TEST
-/*
-START_TEST(UA_Int16_encodeShallWorkOnExample)
+
+START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian)
 {
 	// 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_encodeBinary(&testUInt16, &position, rawMessage.data);
-	// then
-	ck_assert_int_eq(position, 2);
-	UA_Int32 p = 0;
-	UA_UInt16 val;
-	UA_UInt16_decodeBinary(rawMessage.data, &p, &val);
-	ck_assert_int_eq(val,testUInt16);
-	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
-	// finally
-	free(mem);
+	UA_UInt16 src;
+	UA_Byte data[] = { 	0x55,0x55,
+						0x55,0x55
+					};
+	UA_ByteString dst = {4,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = -1;
+	retval = UA_UInt16_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 2);
+	ck_assert_int_eq(dst.data[0], 0xFF);
+	ck_assert_int_eq(dst.data[1], 0xFF);
+	ck_assert_int_eq(retval, UA_SUCCESS);
+
+	// when test 2
+	src = -32768;
+	retval = UA_UInt16_encodeBinary(&src, &pos, &dst);
+	// then test 2
+	ck_assert_int_eq(pos, 4);
+	ck_assert_int_eq(dst.data[2], 0x00);
+	ck_assert_int_eq(dst.data[3], 0x80);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
-START_TEST(UA_UInt16_encodeShallWorkOnExample)
+START_TEST(UA_UInt16_encodeShallEncodeLittleEndian)
 {
 	// 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_encodeBinary(&testUInt16, &position, rawMessage.data);
-	// then
-	ck_assert_int_eq(position, 2);
-	UA_Int32 p = 0;
-	UA_UInt16 val;
-	UA_UInt16_decodeBinary(rawMessage.data, &p, &val);
-	ck_assert_int_eq(val,testUInt16);
-	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
-	// finally
-	free(mem);
+	UA_UInt16 src;
+	UA_Byte data[] = { 	0x55,0x55,
+						0x55,0x55
+					};
+	UA_ByteString dst = {4,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = 0;
+	retval = UA_UInt16_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 2);
+	ck_assert_int_eq(dst.data[0], 0x00);
+	ck_assert_int_eq(dst.data[1], 0x00);
+	ck_assert_int_eq(retval, UA_SUCCESS);
+
+	// when test 2
+	src = 32767;
+	retval = UA_UInt16_encodeBinary(&src, &pos, &dst);
+	// then test 2
+	ck_assert_int_eq(pos, 4);
+	ck_assert_int_eq(dst.data[2], 0xFF);
+	ck_assert_int_eq(dst.data[3], 0x7F);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
-START_TEST(UA_UInt32_encodeShallWorkOnExample)
+START_TEST(UA_UInt32_encodeShallEncodeLittleEndian)
 {
 	// 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_encodeBinary(&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);
+	UA_UInt32 src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {8,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = -1;
+	retval = UA_UInt32_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 4);
+	ck_assert_int_eq(dst.data[0], 0xFF);
+	ck_assert_int_eq(dst.data[1], 0xFF);
+	ck_assert_int_eq(dst.data[2], 0xFF);
+	ck_assert_int_eq(dst.data[3], 0xFF);
+	ck_assert_int_eq(retval, UA_SUCCESS);
+
+	// when test 2
+	src = 0x0101FF00;
+	retval = UA_UInt32_encodeBinary(&src, &pos, &dst);
+	// then test 2
+	ck_assert_int_eq(pos, 8);
+	ck_assert_int_eq(dst.data[4], 0x00);
+	ck_assert_int_eq(dst.data[5], 0xFF);
+	ck_assert_int_eq(dst.data[6], 0x01);
+	ck_assert_int_eq(dst.data[7], 0x01);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
 START_TEST(UA_Int32_encodeShallEncodeLittleEndian)
 {
 	// given
-	UA_Int32 value = 0x01020304;
-	UA_Byte  buf[4];
-	UA_Int32 p = 0;
-	// when
-	UA_Int32_encodeBinary(&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);
+	UA_Int32 src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {8,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = 1;
+	retval = UA_Int32_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 4);
+	ck_assert_int_eq(dst.data[0], 0x01);
+	ck_assert_int_eq(dst.data[1], 0x00);
+	ck_assert_int_eq(dst.data[2], 0x00);
+	ck_assert_int_eq(dst.data[3], 0x00);
+	ck_assert_int_eq(retval, UA_SUCCESS);
+
+	// when test 2
+	src = 0x7FFFFFFF;
+	retval = UA_Int32_encodeBinary(&src, &pos, &dst);
+	// then test 2
+	ck_assert_int_eq(pos, 8);
+	ck_assert_int_eq(dst.data[4], 0xFF);
+	ck_assert_int_eq(dst.data[5], 0xFF);
+	ck_assert_int_eq(dst.data[6], 0xFF);
+	ck_assert_int_eq(dst.data[7], 0x7F);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
 START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian)
 {
 	// given
-	UA_Int32 value = -1;
-	UA_Byte  buf[4];
-	UA_Int32 p = 0;
-	// when
-	UA_Int32_encodeBinary(&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);
+	UA_Int32 src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {8,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = -1;
+	retval = UA_Int32_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 4);
+	ck_assert_int_eq(dst.data[0], 0xFF);
+	ck_assert_int_eq(dst.data[1], 0xFF);
+	ck_assert_int_eq(dst.data[2], 0xFF);
+	ck_assert_int_eq(dst.data[3], 0xFF);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 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_encodeBinary(&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);
+	UA_UInt64 src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {16,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = -1;
+	retval = UA_UInt64_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 8);
+	ck_assert_int_eq(dst.data[0], 0xFF);
+	ck_assert_int_eq(dst.data[1], 0xFF);
+	ck_assert_int_eq(dst.data[2], 0xFF);
+	ck_assert_int_eq(dst.data[3], 0xFF);
+	ck_assert_int_eq(dst.data[4], 0xFF);
+	ck_assert_int_eq(dst.data[5], 0xFF);
+	ck_assert_int_eq(dst.data[6], 0xFF);
+	ck_assert_int_eq(dst.data[7], 0xFF);
+	ck_assert_int_eq(retval, UA_SUCCESS);
+
+	// when test 2
+	src = 0x7F0033AA44EE6611;
+	retval = UA_UInt64_encodeBinary(&src, &pos, &dst);
+	// then test 2
+	ck_assert_int_eq(pos, 16);
+	ck_assert_int_eq(dst.data[8], 0x11);
+	ck_assert_int_eq(dst.data[9], 0x66);
+	ck_assert_int_eq(dst.data[10], 0xEE);
+	ck_assert_int_eq(dst.data[11], 0x44);
+	ck_assert_int_eq(dst.data[12], 0xAA);
+	ck_assert_int_eq(dst.data[13], 0x33);
+	ck_assert_int_eq(dst.data[14], 0x00);
+	ck_assert_int_eq(dst.data[15], 0x7F);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
-START_TEST(UA_Int64_encodeShallWorkOnExample)
+START_TEST(UA_Int64_encodeShallEncodeLittleEndian)
 {
 	// 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_encodeBinary(&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);
+	UA_Int64 src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {16,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = 0x7F0033AA44EE6611;
+	retval = UA_Int64_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 8);
+	ck_assert_int_eq(dst.data[0], 0x11);
+	ck_assert_int_eq(dst.data[1], 0x66);
+	ck_assert_int_eq(dst.data[2], 0xEE);
+	ck_assert_int_eq(dst.data[3], 0x44);
+	ck_assert_int_eq(dst.data[4], 0xAA);
+	ck_assert_int_eq(dst.data[5], 0x33);
+	ck_assert_int_eq(dst.data[6], 0x00);
+	ck_assert_int_eq(dst.data[7], 0x7F);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
-START_TEST(UA_Float_encodeShallWorkOnExample)
+START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian)
 {
 	// given
-	UA_Float value = -6.5;
-	UA_Int32 pos = 0;
-	UA_Byte* buf = (UA_Byte*)malloc(sizeof(UA_Float));
-	// when
-	UA_Float_encodeBinary(&value,&pos,buf);
-	// then
-	ck_assert_uint_eq(buf[2],0xD0);
-	ck_assert_uint_eq(buf[3],0xC0);
-	// finally
-	free(buf);
+	UA_Int64 src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {16,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = -1;
+	retval = UA_Int64_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 8);
+	ck_assert_int_eq(dst.data[0], 0xFF);
+	ck_assert_int_eq(dst.data[1], 0xFF);
+	ck_assert_int_eq(dst.data[2], 0xFF);
+	ck_assert_int_eq(dst.data[3], 0xFF);
+	ck_assert_int_eq(dst.data[4], 0xFF);
+	ck_assert_int_eq(dst.data[5], 0xFF);
+	ck_assert_int_eq(dst.data[6], 0xFF);
+	ck_assert_int_eq(dst.data[7], 0xFF);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
-START_TEST(encodeDouble_test)
+START_TEST(UA_Float_encodeShallWorkOnExample)
 {
-	UA_Double value = -6.5;
-	UA_Int32 pos = 0;
-	UA_Byte* buf = (char*)malloc(sizeof(UA_Double));
+	// given
+	UA_Float src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {16,data};
 
-	UA_Double_encode(&value,&pos,buf);
+	UA_Int32 retval, pos = 0;
 
-	ck_assert_uint_eq(buf[6],0xD0);
-	ck_assert_uint_eq(buf[7],0xC0);
-	free(buf);
+	// when test 1
+	src = -6.5;
+	retval = UA_Float_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 4);
+	ck_assert_int_eq(dst.data[2], 0xD0);
+	ck_assert_int_eq(dst.data[3], 0xC0);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 END_TEST
+/*START_TEST(UA_Double_encodeShallWorkOnExample)
+{
+	// given
+	UA_Double src;
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {16,data};
+
+	UA_Int32 retval, pos = 0;
+
+	// when test 1
+	src = -6.5;
+	retval = UA_Double_encodeBinary(&src, &pos, &dst);
+	// then test 1
+	ck_assert_int_eq(pos, 8);
+	ck_assert_int_eq(dst.data[6], 0xD0);
+	ck_assert_int_eq(dst.data[7], 0xC0);
+	ck_assert_int_eq(retval, UA_SUCCESS);
+}
+END_TEST*/
 START_TEST(UA_String_encodeShallWorkOnExample)
 {
 	// given
-	UA_Int32 pos = 0;
-	UA_String string;
-	UA_Int32 l = 11;
+	UA_String src;
+	src.length = 11;
 	UA_Byte mem[11] = "ACPLT OPCUA";
-	UA_Byte *dstBuf = (UA_Byte*) malloc(sizeof(UA_Int32)+l);
-	string.data =  mem;
-	string.length = 11;
+	src.data = mem;
+
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {24,data};
+
+	UA_Int32 retval, pos = 0;
 	// when
-	UA_String_encodeBinary(&string, &pos, dstBuf);
+	retval = UA_String_encodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(dstBuf[0],11);
-	ck_assert_int_eq(dstBuf[0+sizeof(UA_Int32)],'A');
-	// finally
-	free(dstBuf);
+	ck_assert_int_eq(pos, sizeof(UA_Int32)+11);
+	ck_assert_int_eq(dst.data[0], 11);
+	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+0], 'A');
+	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+1], 'C');
+	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+2], 'P');
+	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+3], 'L');
+	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+4], 'T');
+	ck_assert_int_eq(dst.data[sizeof(UA_Int32)+5], 0x20); //Space
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 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
+	UA_DataValue src;
+	src.serverTimestamp = 80;
+	src.encodingMask = UA_DATAVALUE_SERVERTIMPSTAMP; //Only the sourcePicoseconds
+
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {24,data};
+
+	UA_Int32 retval, pos = 0;
 	// when
-	UA_DataValue_encodeBinary(&dataValue, &pos, buf);
-	//then
+	retval = UA_DataValue_encodeBinary(&src, &pos, &dst);
+	// 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);
+	ck_assert_int_eq(dst.data[0], 0x08); // encodingMask
+	ck_assert_int_eq(dst.data[1], 80); // 8 Byte serverTimestamp
+	ck_assert_int_eq(dst.data[2], 0);
+	ck_assert_int_eq(dst.data[3], 0);
+	ck_assert_int_eq(dst.data[4], 0);
+	ck_assert_int_eq(dst.data[5], 0);
+	ck_assert_int_eq(dst.data[6], 0);
+	ck_assert_int_eq(dst.data[7], 0);
+	ck_assert_int_eq(dst.data[8], 0);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
 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;
+	UA_DataValue src;
+	src.serverTimestamp = 80;
+	src.encodingMask = UA_DATAVALUE_VARIANT | UA_DATAVALUE_SERVERTIMPSTAMP; //Variant & SourvePicoseconds
+	src.value.vt = &UA_[UA_INT32];
+	src.value.arrayLength = 0;
+	src.value.encodingMask = UA_INT32_NS0;
+	UA_Int32 vdata = 45;
+	UA_Int32* pvdata = &vdata;
+	src.value.data = (void**) &pvdata;
+
+	UA_Byte data[] = { 	0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+						0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+					};
+	UA_ByteString dst = {24,data};
+
+	UA_Int32 retval, pos = 0;
 	// when
-	retval = UA_DataValue_encodeBinary(&dataValue, &pos, buf);
+	retval = UA_DataValue_encodeBinary(&src, &pos, &dst);
 	// 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);
+	ck_assert_int_eq(dst.data[0], 0x08 | 0x01); // encodingMask
+	ck_assert_int_eq(dst.data[1], 0x06); // Variant's Encoding Mask - INT32
+	ck_assert_int_eq(dst.data[2], 45);  // the single value
+	ck_assert_int_eq(dst.data[3], 0);
+	ck_assert_int_eq(dst.data[4], 0);
+	ck_assert_int_eq(dst.data[5], 0);
+	ck_assert_int_eq(dst.data[6], 80);  // the server timestamp
+	ck_assert_int_eq(dst.data[7], 0);
+	ck_assert_int_eq(retval, UA_SUCCESS);
 }
-END_TEST*/
+END_TEST
 
 Suite *testSuite_builtin(void)
 {
@@ -1385,17 +1517,19 @@ Suite *testSuite_builtin(void)
 
 	TCase *tc_encode = tcase_create("encode");
 	tcase_add_test(tc_encode, UA_Byte_encode_test);
-/*	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_UInt16_encodeNegativeShallEncodeLittleEndian);
+	tcase_add_test(tc_encode, UA_UInt16_encodeShallEncodeLittleEndian);
+	tcase_add_test(tc_encode, UA_UInt32_encodeShallEncodeLittleEndian);
 	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_Int64_encodeNegativeShallEncodeLittleEndian);
+	tcase_add_test(tc_encode, UA_Int64_encodeShallEncodeLittleEndian);
 	tcase_add_test(tc_encode, UA_Float_encodeShallWorkOnExample);
+	//tcase_add_test(tc_encode, UA_Double_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);*/
+	tcase_add_test(tc_encode, UA_DataValue_encodeShallWorkOnExampleWithVariant);
 	suite_add_tcase(s,tc_encode);
 
 	return s;

tests/check_create.c

@@ -1,23 +0,0 @@
-/*
- ============================================================================
- Name        : check_create.c
- Author      :
- Version     :
- Copyright   : Your copyright notice
- Description :
- ============================================================================
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "opcua.h"
-#include "ua_transportLayer.h"
-#include "check.h"
-
-int main (void)
-{
-	int number_failed = 0;
-
-	return (number_failed != 0);
-}

tests/check_decode.c

@@ -1,359 +0,0 @@
-/*
- ============================================================================
- Name        : check_decode.c
- Author      :
- Version     :
- Copyright   : Your copyright notice
- Description :
- ============================================================================
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "opcua.h"
-#include "ua_transportLayer.h"
-#include "check.h"
-
-/*START_TEST(decodeByte_test)
-{
-	UA_ByteString rawMessage;
-	UA_Int32 position = 0;
-	//EncodeByte
-		UA_Byte* mem = (UA_Byte*) malloc(sizeof(UA_Byte));
-		UA_Byte val;
-
-		rawMessage.data = mem;
-		rawMessage.length = 1;
-		mem[0] = 0x08;
-
-		position = 0;
-
-		UA_Byte_decodeBinary(&rawMessage, &position, &val);
-
-		ck_assert_int_eq(val, 0x08);
-		ck_assert_int_eq(position, 1);
-		free(mem);
-}
-END_TEST
-START_TEST(decodeInt16_test_positives)
-{
-	UA_Int32 p = 0;
-	UA_Int16 val;
-	UA_ByteString rawMessage;
-	UA_Byte mem[] = {
-			0x00,0x00,	// 0
-			0x01,0x00,	// 1
-			0xFF,0x00,	// 255
-			0x00,0x01,	// 256
-	};
-
-	rawMessage.data = mem;
-	rawMessage.length = sizeof(mem);
-	ck_assert_int_eq(rawMessage.length,8);
-
-	UA_Int16_decodeBinary(&rawMessage,&p,&val);
-	ck_assert_int_eq(val,0);
-	UA_Int16_decodeBinary(&rawMessage,&p,&val);
-	ck_assert_int_eq(val,1);
-	UA_Int16_decodeBinary(&rawMessage,&p,&val);
-	ck_assert_int_eq(val,255);
-	UA_Int16_decodeBinary(&rawMessage,&p,&val);
-	ck_assert_int_eq(val,256);
-}
-END_TEST
-START_TEST(decodeInt16_test_negatives)
-{
-	UA_Int32 p = 0;
-	UA_Int16 val;
-	UA_ByteString rawMessage;
-	UA_Byte mem[] = {
-			0xFF,0xFF,	// -1
-			0x00,0x80,	// -32768
-	};
-
-	rawMessage.data = mem;
-	rawMessage.length = sizeof(mem);
-	ck_assert_int_eq(rawMessage.length,4);
-
-	UA_Int16_decodeBinary(&rawMessage,&p,&val);
-	ck_assert_int_eq(val,-1);
-	UA_Int16_decodeBinary(&rawMessage,&p,&val);
-	ck_assert_int_eq(val,-32768);
-}
-END_TEST
-START_TEST(decodeUInt16_test)
-{
-
-	UA_ByteString rawMessage;
-	//EncodeUInt16
-	UA_Byte mem[2] = {0x01,0x00};
-
-	rawMessage.data = mem;
-
-	rawMessage.length = 2;
-
-	//encodeUInt16(testUInt16, &position, &rawMessage);
-
-	UA_Int32 p = 0;
-	UA_UInt16 val;
-	UA_UInt16_decodeBinary(&rawMessage,&p,&val);
-
-	ck_assert_int_eq(val,1);
-	//ck_assert_int_eq(p, 2);
-	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
-
-}
-END_TEST*/
-/*START_TEST(decodeUInt32_test)
-{
-	UA_ByteString rawMessage;
-	//EncodeUInt16
-	UA_Byte mem[4] = {0xFF,0x00,0x00,0x00};
-
-	rawMessage.data = mem;
-	rawMessage.length = 4;
-
-	UA_Int32 p = 0;
-	UA_UInt32 val;
-	UA_UInt32_decodeBinary(&rawMessage, &p, &val);
-	ck_assert_uint_eq(val,255);
-
-}
-END_TEST
-START_TEST(decodeInt32_test)
-{
-	UA_ByteString rawMessage;
-	//EncodeUInt16
-	UA_Byte mem[4] = {0x00,0xCA,0x9A,0x3B};
-
-	rawMessage.data = mem;
-
-	rawMessage.length = 4;
-
-
-	UA_Int32 p = 0;
-	UA_Int32 val;
-	UA_Int32_decodeBinary(&rawMessage, &p, &val);
-	ck_assert_int_eq(val,1000000000);
-}
-END_TEST*/
-/*START_TEST(decodeUInt64_test)
-{
-	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;
-	UA_UInt64_decodeBinary(&rawMessage, &p, &val);
-	ck_assert_uint_eq(val, expectedVal);
-}
-END_TEST
-START_TEST(decodeInt64_test)
-{
-	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;
-	UA_Int64_decodeBinary(&rawMessage, &p, &val);
-	ck_assert_uint_eq(val, expectedVal);
-}
-END_TEST*/
-/*START_TEST(decodeFloat_test)
-{
-	UA_Int32 pos = 0;
-	UA_Byte buf[4] = {0x00,0x00,0xD0,0xC0};
-	UA_ByteString src = {4,buf};
-
-	UA_Float fval;
-
-	UA_Float_decodeBinary(&src, &pos, &fval);
-	//val should be -6.5
-	UA_Int32 val = (fval > -6.501 && fval < -6.499);
-	ck_assert_int_gt(val,0);
-}
-END_TEST
-START_TEST(decodeDouble_test)
-{
-
-}
-END_TEST
-START_TEST(decodeUAString_test)
-{
-
-	UA_Int32 pos = 0;
-	UA_Int32 retval = UA_SUCCESS;
-	UA_String string;
-	UA_Byte binString[12] = {0x08,0x00,0x00,0x00,'A','C','P','L','T',' ','U','A'};
-	UA_ByteString src = { 12, binString };
-
-	retval = UA_String_decodeBinary(&src, &pos, &string);
-
-	ck_assert_int_eq(retval,UA_SUCCESS);
-	ck_assert_int_eq(string.length,8);
-	ck_assert_ptr_eq(string.data,UA_alloc_lastptr);
-	ck_assert_int_eq(string.data[3],'L');
-
-	UA_String_deleteMembers(&string);
-}
-END_TEST*/
-/*
-Suite *testSuite_decodeByte(void)
-{
-	Suite *s = suite_create("encodeByte_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeByte_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite *testSuite_decodeInt16(void)
-{
-	Suite *s = suite_create("decodeInt16_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeInt16_test_positives);
-	tcase_add_test(tc_core, decodeInt16_test_negatives);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite *testSuite_decodeUInt16(void)
-{
-	Suite *s = suite_create("decodeUInt16_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeUInt16_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_decodeUInt32(void)
-{
-	Suite *s = suite_create("decodeUInt32_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeUInt32_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_decodeInt32(void)
-{
-	Suite *s = suite_create("decodeInt32_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeInt32_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_decodeInt64(void)
-{
-	Suite *s = suite_create("decodeInt64_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeInt64_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_decodeUInt64(void)
-{
-	Suite *s = suite_create("decodeUInt64_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeUInt64_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite *testSuite_decodeFloat(void)
-{
-	Suite *s = suite_create("decodeFloat_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeFloat_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite *testSuite_decodeDouble(void)
-{
-	Suite *s = suite_create("decodeDouble_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, decodeDouble_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite * testSuite_decodeUAString(void)
-{
-	Suite *s = suite_create("decodeUAString_test");
-	TCase *tc_core = tcase_create("Core");
-	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);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeInt16();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeUInt16();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeUInt32();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeInt32();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeUInt64();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeInt64();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_decodeUAString();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-*/
-
-
-	/* <TESTSUITE_TEMPLATE>
-	s =  <TESTSUITENAME>;
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-	*/
-	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-

tests/check_delete.c

@@ -1,23 +0,0 @@
-/*
- ============================================================================
- Name        : check_delete.c
- Author      :
- Version     :
- Copyright   : Your copyright notice
- Description :
- ============================================================================
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "opcua.h"
-#include "ua_transportLayer.h"
-#include "check.h"
-
-int main (void)
-{
-	int number_failed = 0;
-
-	return (number_failed != 0);
-}

tests/check_encode.c

@@ -1,466 +0,0 @@
-/*
- ============================================================================
- Name        : check_encode.c
- Author      :
- Version     :
- Copyright   : Your copyright notice
- Description :
- ============================================================================
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "opcua.h"
-#include "ua_transportLayer.h"
-#include "check.h"
-
-
-/*START_TEST(encodeByte_test)
-{
-	UA_ByteString rawMessage;
-	UA_Int32 position = 0;
-	//EncodeByte
-	UA_Byte *mem = malloc(sizeof(UA_Byte));
-		rawMessage.data = mem;
-		UA_Byte testByte = 0x08;
-		rawMessage.length = 1;
-		position = 0;
-
-		UA_Byte_encodeBinary(&(testByte), &position, &rawMessage);
-
-		ck_assert_int_eq(rawMessage.data[0], 0x08);
-		ck_assert_int_eq(rawMessage.length, 1);
-		ck_assert_int_eq(position, 1);
-
-		free(mem);
-}
-END_TEST
-START_TEST(encodeInt16_test)
-{
-
-	UA_ByteString rawMessage;
-	UA_Int32 position = 0;
-	//EncodeUInt16
-	UA_Byte *mem = malloc(sizeof(UA_UInt16));
-	rawMessage.data = mem;
-	UA_UInt16 testUInt16 = 1;
-	rawMessage.length = 2;
-	position = 0;
-
-	UA_UInt16_encodeBinary(&testUInt16, &position, &rawMessage);
-
-	ck_assert_int_eq(position, 2);
-	UA_Int32 p = 0;
-	UA_UInt16 val;
-	UA_UInt16_decodeBinary(&rawMessage, &p, &val);
-	ck_assert_int_eq(val,testUInt16);
-	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
-
-	free(mem);
-}
-END_TEST
-START_TEST(encodeUInt16_test)
-{
-
-	UA_ByteString rawMessage;
-	UA_Int32 position = 0;
-	//EncodeUInt16
-	UA_Byte *mem = (UA_Byte*) malloc(sizeof(UA_UInt16));
-	rawMessage.data = mem;
-	UA_UInt16 testUInt16 = 1;
-	rawMessage.length = 2;
-	position = 0;
-
-	UA_UInt16_encodeBinary(&testUInt16, &position, &rawMessage);
-	ck_assert_int_eq(position, 2);
-
-	UA_Int32 p = 0;
-	UA_UInt16 val;
-	UA_UInt16_decodeBinary(&rawMessage, &p, &val);
-	ck_assert_int_eq(val,testUInt16);
-	//ck_assert_int_eq(rawMessage.data[0], 0xAB);
-
-	free(mem);
-}
-END_TEST
-START_TEST(encodeUInt32_test)
-{
-	UA_ByteString rawMessage;
-	UA_UInt32 value = 0x0101FF00;
-	//EncodeUInt16
-
-	rawMessage.data = (UA_Byte*) malloc(2 * sizeof(UA_UInt32));
-
-	rawMessage.length = 8;
-
-	UA_Int32 p = 4;
-	UA_UInt32_encodeBinary(&value,&p,&rawMessage);
-	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);
-
-	free(rawMessage.data);
-
-}
-END_TEST
-START_TEST(encodeInt32ShallEncodeLittleEndian)
-{
-	// given
-	UA_Int32 value = 0x01020304;
-	UA_Byte  buf[4];
-	UA_ByteString dst = {4,buf};
-	UA_Int32 p = 0;
-	// when
-	UA_Int32_encodeBinary(&value,&p,&dst);
-	// 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(encodeInt32NegativeShallEncodeLittleEndian)
-{
-	// given
-	UA_Int32 value = -1;
-	UA_Byte  buf[4];
-	UA_ByteString dst = {4,buf};
-	UA_Int32 p = 0;
-	// when
-	UA_Int32_encodeBinary(&value,&p,&dst);
-	// 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(encodeUInt64_test)
-{
-	UA_ByteString rawMessage;
-	UA_UInt64 value = 0x0101FF00FF00FF00;
-	//EncodeUInt16
-
-	rawMessage.data = (UA_Byte*) malloc(sizeof(UA_UInt64));
-
-	rawMessage.length = 8;
-
-	UA_Int32 p = 0;
-	UA_UInt64_encodeBinary(&value, &p,&rawMessage);
-
-	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);
-
-	free(rawMessage.data);
-}
-END_TEST
-START_TEST(encodeInt64_test)
-{
-	UA_ByteString rawMessage;
-	UA_UInt64 value = 0x0101FF00FF00FF00;
-	//EncodeUInt16
-
-	rawMessage.data = (UA_Byte*) malloc(sizeof(UA_UInt64));
-
-	rawMessage.length = 8;
-
-	UA_Int32 p = 0;
-	UA_UInt64_encodeBinary(&value, &p,&rawMessage);
-
-	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);
-
-	free(rawMessage.data);
-}
-END_TEST
-START_TEST(encodeFloat_test)
-{
-	UA_Float value = -6.5;
-	UA_Int32 pos = 0;
-	UA_Byte* buf = (UA_Byte*)malloc(sizeof(UA_Float));
-	UA_ByteString dst = { sizeof(UA_Float), buf };
-
-	UA_Float_encodeBinary(&value,&pos,&dst);
-
-	ck_assert_uint_eq(buf[2],0xD0);
-	ck_assert_uint_eq(buf[3],0xC0);
-	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(encodeUAString_test)
-{
-
-	UA_Int32 pos = 0;
-	UA_String string;
-	UA_Byte mem[] = "ACPLT OPCUA";
-	string.data =  mem;
-	string.length = sizeof(mem)-1; // w/o trailing \0
-
-	UA_Byte *buf = (UA_Byte*) malloc(sizeof(UA_Int32)+string.length);
-	UA_ByteString dst = {string.length+4, buf};
-
-	UA_String_encodeBinary(&string, &pos, &dst);
-
-	ck_assert_int_eq(buf[0],11);
-	ck_assert_int_eq(buf[4],'A');
-
-	free(buf);
-}
-END_TEST
-START_TEST(encodeDataValue_test)
-{
-	UA_DataValue dataValue;
-	UA_Int32 pos = 0, retval;
-	UA_Byte* buf = (UA_Byte*) malloc(15);
-	UA_ByteString dst = {15,buf};
-	UA_DateTime dateTime;
-	dateTime = 80;
-	dataValue.serverTimestamp = dateTime;
-
-	//--without Variant
-	dataValue.encodingMask = UA_DATAVALUE_SERVERTIMPSTAMP; //Only the sourcePicoseconds
-	UA_DataValue_encodeBinary(&dataValue, &pos, &dst);
-
-	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);
-
-	//TestCase for a DataValue with a Variant!
-	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_Int32 data = 45;
-	UA_Int32* pdata = &data;
-	dataValue.value.data = (void**) &pdata;
-
-	pos = 0;
-	retval = UA_DataValue_encodeBinary(&dataValue, &pos, &dst);
-
-	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);
-
-	free(buf);
-}
-END_TEST*/
-/*
-
-
-Suite *testSuite_encodeByte(void)
-{
-	Suite *s = suite_create("encodeByte_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeByte_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_encodeInt16(void)
-{
-	Suite *s = suite_create("encodeInt16_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeInt16_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_encodeUInt16(void)
-{
-	Suite *s = suite_create("encodeUInt16_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeUInt16_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_encodeUInt32(void)
-{
-	Suite *s = suite_create("encodeUInt32_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeUInt32_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_encodeInt32(void)
-{
-	Suite *s = suite_create("encodeInt32_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeInt32ShallEncodeLittleEndian);
-	tcase_add_test(tc_core, encodeInt32NegativeShallEncodeLittleEndian);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_encodeUInt64(void)
-{
-	Suite *s = suite_create("encodeUInt64_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeUInt64_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite*testSuite_encodeInt64(void)
-{
-	Suite *s = suite_create("encodeInt64_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeInt64_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite *testSuite_encodeFloat(void)
-{
-	Suite *s = suite_create("encodeFloat_test");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeFloat_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-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");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeUAString_test);
-	suite_add_tcase(s,tc_core);
-	return s;
-}
-Suite* testSuite_encodeDataValue()
-{
-	Suite *s = suite_create("encodeDataValue");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeDataValue_test);
-	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);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeInt16();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeUInt16();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeUInt32();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeInt32();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeUInt64();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeInt64();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeFloat();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeDouble();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeUAString();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-
-	s = testSuite_encodeDataValue();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-*/
-
-	/* <TESTSUITE_TEMPLATE>
-	s =  <TESTSUITENAME>;
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-	*/
-	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}