make tests crash at a later point

include/ua_types.h

@@ -254,7 +254,7 @@ typedef struct {
 /** @brief A structure that contains detailed error and diagnostic information associated with a StatusCode. */
 typedef struct UA_DiagnosticInfo {
     UA_Boolean    hasSymbolicId : 1;
-    UA_Boolean    hasNamespace : 1;
+    UA_Boolean    hasNamespaceUri : 1;
     UA_Boolean    hasLocalizedText : 1;
     UA_Boolean    hasLocale : 1;
     UA_Boolean    hasAdditionalInfo : 1;

src/ua_types.c

@@ -886,9 +886,13 @@ UA_StatusCode UA_copy(const void *src, void *dst, const UA_DataType *dataType) {
             *dstNoElements = noElements;
             ptrs += sizeof(void*);
             ptrd += sizeof(void*);
-        } else {
-            ptrs += member->padding;
-            ptrd += member->padding;
+            continue;
+        }
+
+        ptrs += member->padding;
+        ptrd += member->padding;
+
+        if(!member->namespaceZero) {
             UA_StatusCode retval = UA_copy(ptrs, ptrd, memberType);
             if(retval != UA_STATUSCODE_GOOD) {
                 UA_deleteMembers(dst, dataType);
@@ -896,7 +900,68 @@ UA_StatusCode UA_copy(const void *src, void *dst, const UA_DataType *dataType) {
             }
             ptrs += memberType->memSize;
             ptrd += memberType->memSize;
+            continue;
+        }
+
+        switch(member->memberTypeIndex) {
+        case UA_TYPES_BOOLEAN:
+        case UA_TYPES_SBYTE:
+        case UA_TYPES_BYTE:
+            *((UA_Byte*)ptrd) = *((const UA_Byte*)ptrs);
+            break;
+        case UA_TYPES_INT16:
+        case UA_TYPES_UINT16:
+            *((UA_Int16*)ptrd) = *((const UA_Byte*)ptrs);
+            break;
+        case UA_TYPES_INT32:
+        case UA_TYPES_UINT32:
+        case UA_TYPES_STATUSCODE:
+        case UA_TYPES_FLOAT:
+            *((UA_Int32*)ptrd) = *((const UA_Int32*)ptrs);
+            break;
+        case UA_TYPES_INT64:
+        case UA_TYPES_UINT64:
+        case UA_TYPES_DOUBLE:
+        case UA_TYPES_DATETIME:
+            *((UA_Int64*)ptrd) = *((const UA_Int64*)ptrs);
+            break;
+        case UA_TYPES_GUID:
+            *((UA_Guid*)ptrd) = *((const UA_Guid*)ptrs);
+            break;
+        case UA_TYPES_NODEID:
+            UA_NodeId_copy((const UA_NodeId*)ptrs, (UA_NodeId*)ptrd);
+            break;
+        case UA_TYPES_EXPANDEDNODEID:
+            UA_ExpandedNodeId_copy((const UA_ExpandedNodeId*)ptrs, (UA_ExpandedNodeId*)ptrd);
+            break;
+        case UA_TYPES_QUALIFIEDNAME:
+            UA_QualifiedName_copy((const UA_QualifiedName*)ptrs, (UA_QualifiedName*)ptrd);
+            break;
+        case UA_TYPES_LOCALIZEDTEXT:
+            UA_LocalizedText_copy((const UA_LocalizedText*)ptrs, (UA_LocalizedText*)ptrd);
+            break;
+        case UA_TYPES_EXTENSIONOBJECT:
+            UA_ExtensionObject_copy((const UA_ExtensionObject*)ptrs, (UA_ExtensionObject*)ptrd);
+            break;
+        case UA_TYPES_DATAVALUE:
+            UA_DataValue_copy((const UA_DataValue*)ptrs, (UA_DataValue*)ptrd);
+            break;
+        case UA_TYPES_VARIANT:
+            UA_Variant_copy((const UA_Variant*)ptrs, (UA_Variant*)ptrd);
+            break;
+        case UA_TYPES_DIAGNOSTICINFO:
+            UA_DiagnosticInfo_copy((const UA_DiagnosticInfo*)ptrs, (UA_DiagnosticInfo*)ptrd);
+            break;
+        case UA_TYPES_STRING:
+        case UA_TYPES_BYTESTRING:
+        case UA_TYPES_XMLELEMENT:
+            UA_String_copy((const UA_String*)ptrs, (UA_String*)ptrd);
+            break;
+        default:
+            UA_copy(ptrs, ptrd, &UA_TYPES[member->memberTypeIndex]);
         }
+        ptrs += memberType->memSize;
+        ptrd += memberType->memSize;
     }
     return UA_STATUSCODE_GOOD;
 }

src/ua_types_encoding_binary.c

@@ -21,7 +21,7 @@ UA_StatusCode UA_Boolean_decodeBinary(UA_ByteString const *src, UA_UInt32 *offse
     if(*offset + sizeof(UA_Boolean) > (UA_UInt32)src->length )
         return UA_STATUSCODE_BADDECODINGERROR;
     *dst = (src->data[*offset] > 0) ? UA_TRUE : UA_FALSE;
-    offset++;
+    (*offset)++;
     return UA_STATUSCODE_GOOD;
 }
 
@@ -39,7 +39,7 @@ UA_StatusCode UA_SByte_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset,
     if(*offset + sizeof(UA_SByte) > (UA_UInt32)src->length )
         return UA_STATUSCODE_BADDECODINGERROR;
     *dst = (UA_SByte)src->data[*offset];
-    (offset)++;
+    (*offset)++;
     return UA_STATUSCODE_GOOD;
 }
 
@@ -57,7 +57,7 @@ UA_StatusCode UA_Byte_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset,
     if(*offset + sizeof(UA_Byte) > (UA_UInt32)src->length )
         return UA_STATUSCODE_BADDECODINGERROR;
     *dst = src->data[*offset];
-    (offset)++;
+    (*offset)++;
     return UA_STATUSCODE_GOOD;
 }
 
@@ -890,7 +890,7 @@ UA_UInt32 UA_DiagnosticInfo_calcSizeBinary(UA_DiagnosticInfo const *ptr) {
     UA_UInt32 length = sizeof(UA_Byte);
     if(ptr->hasSymbolicId)
         length += sizeof(UA_Int32);
-    if(ptr->hasNamespace)
+    if(ptr->hasNamespaceUri)
         length += sizeof(UA_Int32);
     if(ptr->hasLocalizedText)
         length += sizeof(UA_Int32);
@@ -909,7 +909,7 @@ UA_StatusCode UA_DiagnosticInfo_encodeBinary(const UA_DiagnosticInfo *src, UA_By
     UA_StatusCode retval = UA_Byte_encodeBinary((const UA_Byte *)src, dst, offset);
     if(src->hasSymbolicId)
         retval |= UA_Int32_encodeBinary(&src->symbolicId, dst, offset);
-    if(src->hasNamespace)
+    if(src->hasNamespaceUri)
         retval |= UA_Int32_encodeBinary( &src->namespaceUri, dst, offset);
     if(src->hasLocalizedText)
         retval |= UA_Int32_encodeBinary(&src->localizedText, dst, offset);
@@ -931,7 +931,7 @@ UA_StatusCode UA_DiagnosticInfo_decodeBinary(UA_ByteString const *src, UA_UInt32
         return retval;
     if(dst->hasSymbolicId)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->symbolicId);
-    if(dst->hasNamespace)
+    if(dst->hasNamespaceUri)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->namespaceUri);
     if(dst->hasLocalizedText)
         retval |= UA_Int32_decodeBinary(src, offset, &dst->localizedText);

tests/check_builtin.c

@@ -43,17 +43,16 @@ START_TEST(UA_DataValue_calcSizeShallWorkOnExample) {
 	UA_DataValue dataValue;
 	dataValue.status       = 12;
     dataValue.hasStatus = UA_TRUE;
-	UA_DateTime dateTime = 80;
-	dataValue.sourceTimestamp = dateTime;
+	dataValue.sourceTimestamp = 80;
     dataValue.hasSourceTimestamp = UA_TRUE;
-	UA_DateTime sourceTime = 214;
-	dataValue.sourcePicoseconds = sourceTime;
+	dataValue.sourcePicoseconds = 214;
     dataValue.hasSourcePicoseconds = UA_TRUE;
 	int size = 0;
 	// when
 	size = UA_DataValue_calcSizeBinary(&dataValue);
 	// then
-	ck_assert_int_eq(size, 21);
+    // 1 (bitfield) + 4 (status) + 8 (timestamp) + 2 (picoseconds)
+	ck_assert_int_eq(size, 15);
 }
 END_TEST
 
@@ -63,15 +62,16 @@ START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
 	diagnosticInfo.symbolicId    = 30;
     diagnosticInfo.hasSymbolicId = UA_TRUE;
 	diagnosticInfo.namespaceUri  = 25;
-    diagnosticInfo.hasNamespace = UA_TRUE;
+    diagnosticInfo.hasNamespaceUri = UA_TRUE;
 	diagnosticInfo.localizedText = 22;
     diagnosticInfo.hasLocalizedText = UA_TRUE;
 	UA_Byte additionalInfoData = 'd';
 	diagnosticInfo.additionalInfo.data = &additionalInfoData; //"OPCUA";
-	diagnosticInfo.additionalInfo.length = 5;
+	diagnosticInfo.additionalInfo.length = 1;
     diagnosticInfo.hasAdditionalInfo = UA_TRUE;
 	// when & then
-	ck_assert_int_eq(UA_DiagnosticInfo_calcSizeBinary(&diagnosticInfo), 26);
+    // 1 (bitfield) + 4 (symbolic id) + 4 (namespaceuri) + 4 (localizedtext) + 5 (additionalinfo)
+	ck_assert_int_eq(UA_DiagnosticInfo_calcSizeBinary(&diagnosticInfo), 18);
 }
 END_TEST
 
@@ -1778,7 +1778,7 @@ int main(void) {
 
 	s  = testSuite_builtin();
 	sr = srunner_create(s);
-	//srunner_set_fork_status(sr, CK_NOFORK);
+	srunner_set_fork_status(sr, CK_NOFORK);
 	srunner_run_all(sr, CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);