update statuscode

include/ua_types.h

@@ -47,23 +47,28 @@ typedef enum UA_EQUALITY {
  *
  * All datatypes follow the same schema in the naming of relevant functions.
  *
- * - <type>_init: Sets all values to a "safe" standard. For example, if the
- *     datatype contains a string-element, its size will be set to zero.
+ * DO NOT CALL THESE FUNCTIONS WITH NULL-POINTERS IF IT IS NOT EXPLICITLY
+ * PERMITTED.
  *
  * - <type>_new: Allocates the memory for the type and runs <type>_init on the
- *     returned pointer.
+ *     returned variable.
+ *
+ * - <type>_init: Sets all members to a "safe" standard, usually zero. Arrays
+ *   (e.g. for strings) are set to a length of -1.
  *
  * - <type>_copy: Copies a datatype. This performs a deep copy that iterates
- *    over the members. The copy function assumes that the target structure can
- *    be overwritten (do a deleteMembers before if necessary). With one
- *    exception: copying into a variant that points to an external datasource is
- *    not permitted.
+ *    over the members. The copy function assumes that the destination is clean
+ *    (after an _init). Copying into variants with an external data source is
+ *    not permitted. If copying fails, the destination is returned clean.
  *
- * - <type>_delete: Frees the memory where the datatype was stored.
+ * - <type>_delete: Frees the memory where the datatype was stored. This
+ *   performs an _deleteMembers internally if required.
  *
  * - <type>_deleteMembers: Frees the memory of dynamically sized members (e.g. a
  *   string) of a datatype. This is useful when the datatype was allocated on
- *   the stack, whereas the dynamically sized members is heap-allocated.
+ *   the stack, whereas the dynamically sized members is heap-allocated. To
+ *   reuse the variable, the remaining members (not dynamically allocated) need
+ *   to be cleaned up with an _init.
  *
  * @{
  */
@@ -487,7 +492,6 @@ struct UA_VTable_Entry {
 
 #define UA_TYPE_INIT_DEFAULT(TYPE) \
     void TYPE##_init(TYPE * p) {   \
-        if(!p) return;             \
         *p = (TYPE)0;              \
     }
 
@@ -498,7 +502,6 @@ struct UA_VTable_Entry {
 
 #define UA_TYPE_DELETE_DEFAULT(TYPE) \
     void TYPE##_delete(TYPE *p) {    \
-        if(!p) return;               \
         TYPE##_deleteMembers(p);     \
         UA_free(p);                  \
     }
@@ -517,14 +520,12 @@ struct UA_VTable_Entry {
 /* Use only when the type has no arrays. Otherwise, implement deep copy */
 #define UA_TYPE_COPY_DEFAULT(TYPE)                             \
     UA_StatusCode TYPE##_copy(TYPE const *src, TYPE *dst) {    \
-        if(src == UA_NULL || dst == UA_NULL)                   \
-            return UA_STATUSCODE_BADOUTOFMEMORY;               \
         *dst = *src;                                           \
         return UA_STATUSCODE_GOOD;                             \
     }
 
 #define UA_TYPE_COPY_AS(TYPE, TYPE_AS)                         \
-    UA_Int32 TYPE##_copy(TYPE const *src, TYPE *dst) {         \
+    UA_StatusCode TYPE##_copy(TYPE const *src, TYPE *dst) {         \
         return TYPE_AS##_copy((TYPE_AS *)src, (TYPE_AS *)dst); \
     }
 

src/ua_types.c

@@ -19,7 +19,6 @@
 
 /* Boolean */
 void UA_Boolean_init(UA_Boolean *p) {
-    if(!p) return;
     *p = UA_FALSE;
 }
 
@@ -29,7 +28,6 @@ UA_TYPE_NEW_DEFAULT(UA_Boolean)
 UA_TYPE_COPY_DEFAULT(UA_Boolean)
 #ifdef DEBUG
 void UA_Boolean_print(const UA_Boolean *p, FILE *stream) {
-    if(!p || !stream) return;
     if(*p) fprintf(stream, "UA_TRUE");
     else fprintf(stream, "UA_FALSE");
 }
@@ -130,22 +128,17 @@ void UA_Double_print(const UA_Double *p, FILE *stream) {
 /* String */
 UA_TYPE_NEW_DEFAULT(UA_String)
 void UA_String_init(UA_String *p) {
-    if(!p) return;
     p->length = -1;
     p->data   = UA_NULL;
 }
 
 UA_TYPE_DELETE_DEFAULT(UA_String)
 void UA_String_deleteMembers(UA_String *p) {
-    if(p->data != UA_NULL) {
-        UA_free(p->data);
-        UA_String_init(p);
-    }
+    UA_free(p->data);
+    UA_String_init(p);
 }
 
 UA_StatusCode UA_String_copy(UA_String const *src, UA_String *dst) {
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
     if(src->length > 0) {
         if(!(dst->data = UA_alloc(src->length)))
             return UA_STATUSCODE_BADOUTOFMEMORY;
@@ -157,8 +150,6 @@ UA_StatusCode UA_String_copy(UA_String const *src, UA_String *dst) {
 
 #ifdef DEBUG
 void UA_String_print(const UA_String *p, FILE *stream) {
-    if(!p || !stream)
-        return;
     fprintf(stream, "(UA_String){%d,", p->length);
     if(p->data)
         fprintf(stream, "\"%.*s\"}", p->length, p->data);
@@ -180,30 +171,24 @@ UA_Int32 UA_String_copycstring(char const *src, UA_String *dst) {
 
 #define UA_STRING_COPYPRINTF_BUFSIZE 1024
 UA_StatusCode UA_String_copyprintf(char const *fmt, UA_String *dst, ...) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    char          src[UA_STRING_COPYPRINTF_BUFSIZE];
-    UA_Int32      len;
-    va_list       ap;
+    char src[UA_STRING_COPYPRINTF_BUFSIZE];
+    va_list ap;
     va_start(ap, dst);
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
     // vsnprintf should only take a literal and no variable to be secure
-    len = vsnprintf(src, UA_STRING_COPYPRINTF_BUFSIZE, fmt, ap);
+    UA_Int32 len = vsnprintf(src, UA_STRING_COPYPRINTF_BUFSIZE, fmt, ap);
 #pragma GCC diagnostic pop
     va_end(ap);
-    if(len < 0) {  // FIXME: old glibc 2.0 would return -1 when truncated
-        dst->length = 0;
-        dst->data   = UA_NULL;
-        retval      = UA_STATUSCODE_BADINTERNALERROR;
-    } else {
-        // since glibc 2.1 vsnprintf returns len that would have resulted if buf were large enough
-        dst->length = ( len > UA_STRING_COPYPRINTF_BUFSIZE ? UA_STRING_COPYPRINTF_BUFSIZE : len );
-        if((dst->data = UA_alloc(dst->length)))
-            UA_memcpy((void *)dst->data, src, dst->length);
-        else
-            retval = UA_STATUSCODE_BADOUTOFMEMORY;
-    }
-    return retval;
+    if(len < 0)  // FIXME: old glibc 2.0 would return -1 when truncated
+        return UA_STATUSCODE_BADINTERNALERROR;
+    // since glibc 2.1 vsnprintf returns len that would have resulted if buf were large enough
+    len = ( len > UA_STRING_COPYPRINTF_BUFSIZE ? UA_STRING_COPYPRINTF_BUFSIZE : len );
+    if(!(dst->data = UA_alloc(dst->length)))
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+    UA_memcpy((void *)dst->data, src, len);
+    dst->length = len;
+    return UA_STATUSCODE_GOOD;
 }
 
 UA_EQUALITY UA_String_equal(const UA_String *string1, const UA_String *string2) {
@@ -226,10 +211,6 @@ void UA_String_printf(char const *label, const UA_String *string) {
 
 #ifdef DEBUG
 void UA_String_printx(char const *label, const UA_String *string) {
-    if(!string) {
-        printf("%s {NULL}\n", label);
-        return;
-    }
     printf("%s {Length=%d, Data=", label, string->length);
     if(string->length > 0) {
         for(UA_Int32 i = 0;i < string->length;i++) {
@@ -338,7 +319,6 @@ UA_EQUALITY UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2) {
 }
 
 void UA_Guid_init(UA_Guid *p) {
-    if(!p) return;
     p->data1 = 0;
     p->data2 = 0;
     p->data3 = 0;
@@ -347,15 +327,12 @@ void UA_Guid_init(UA_Guid *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_Guid)
 UA_StatusCode UA_Guid_copy(UA_Guid const *src, UA_Guid *dst) {
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
     UA_memcpy((void *)dst, (void *)src, sizeof(UA_Guid));
     return UA_STATUSCODE_GOOD;
 }
 
 #ifdef DEBUG
 void UA_Guid_print(const UA_Guid *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_Guid){%u, %u %u {%x,%x,%x,%x,%x,%x,%x,%x}}", p->data1, p->data2, p->data3, p->data4[0],
             p->data4[1], p->data4[2], p->data4[3], p->data4[4], p->data4[5], p->data4[6], p->data4[7]);
 }
@@ -390,6 +367,7 @@ UA_Byte       UA_Byte_securityPoliceNoneData[] = "http://opcfoundation.org/UA/Se
 UA_ByteString UA_ByteString_securityPoliceNone =
 { sizeof(UA_Byte_securityPoliceNoneData)-1, UA_Byte_securityPoliceNoneData };
 
+/** Creates a ByteString of the indicated length. The content is not set to zero. */
 UA_StatusCode UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length) {
     UA_StatusCode retval = UA_STATUSCODE_GOOD;
     if(length > 0) {
@@ -410,7 +388,6 @@ UA_TYPE_AS(UA_XmlElement, UA_ByteString)
 
 /* NodeId */
 void UA_NodeId_init(UA_NodeId *p) {
-    if(!p) return;
     p->identifierType = UA_NODEIDTYPE_NUMERIC;
     p->namespaceIndex = 0;
     memset(&p->identifier, 0, sizeof(p->identifier));
@@ -419,9 +396,6 @@ void UA_NodeId_init(UA_NodeId *p) {
 UA_TYPE_NEW_DEFAULT(UA_NodeId)
 UA_StatusCode UA_NodeId_copy(UA_NodeId const *src, UA_NodeId *dst) {
     UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
-
     switch(src->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
         *dst = *src;
@@ -441,6 +415,10 @@ UA_StatusCode UA_NodeId_copy(UA_NodeId const *src, UA_NodeId *dst) {
         break;
     }
     dst->identifierType = src->identifierType;
+    if(retval) {
+        UA_NodeId_deleteMembers(dst);
+        UA_NodeId_init(dst);
+    }
     return retval;
 }
 
@@ -452,8 +430,6 @@ UA_Boolean UA_NodeId_isBasicType(UA_NodeId const *id) {
 
 UA_TYPE_DELETE_DEFAULT(UA_NodeId)
 void UA_NodeId_deleteMembers(UA_NodeId *p) {
-    if(!p) return;
-
     switch(p->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
         // nothing to do
@@ -474,8 +450,6 @@ void UA_NodeId_deleteMembers(UA_NodeId *p) {
 
 #ifdef DEBUG
 void UA_NodeId_print(const UA_NodeId *p, FILE *stream) {
-    if(!p || !stream) return;
-
     fprintf(stream, "(UA_NodeId){");
     switch(p->identifierType) {
     case UA_NODEIDTYPE_NUMERIC:
@@ -527,7 +501,7 @@ void UA_NodeId_print(const UA_NodeId *p, FILE *stream) {
 #endif
 
 UA_EQUALITY UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
-    if(!n1 || !n2 || n1->namespaceIndex != n2->namespaceIndex)
+    if(n1->namespaceIndex != n2->namespaceIndex)
         return UA_NOT_EQUAL;
 
     switch(n1->identifierType) {
@@ -581,13 +555,11 @@ UA_Boolean UA_NodeId_isNull(const UA_NodeId *p) {
 /* ExpandedNodeId */
 UA_TYPE_DELETE_DEFAULT(UA_ExpandedNodeId)
 void UA_ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p) {
-    if(!p) return;
     UA_NodeId_deleteMembers(&p->nodeId);
     UA_String_deleteMembers(&p->namespaceUri);
 }
 
 void UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) {
-    if(!p) return;
     UA_NodeId_init(&p->nodeId);
     UA_String_init(&p->namespaceUri);
     p->serverIndex = 0;
@@ -596,19 +568,18 @@ void UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) {
 UA_TYPE_NEW_DEFAULT(UA_ExpandedNodeId)
 UA_StatusCode UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst) {
     UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
     retval |= UA_String_copy(&src->namespaceUri, &dst->namespaceUri);
     retval |= UA_NodeId_copy(&src->nodeId, &dst->nodeId);
     dst->serverIndex = src->serverIndex;
-    if(retval)
+    if(retval) {
         UA_ExpandedNodeId_deleteMembers(dst);
+        UA_ExpandedNodeId_init(dst);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_ExpandedNodeId_print(const UA_ExpandedNodeId *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_ExpandedNodeId){");
     UA_NodeId_print(&p->nodeId, stream);
     fprintf(stream, ",");
@@ -629,25 +600,22 @@ UA_TYPE_AS(UA_StatusCode, UA_UInt32)
 /* QualifiedName */
 UA_TYPE_DELETE_DEFAULT(UA_QualifiedName)
 void UA_QualifiedName_deleteMembers(UA_QualifiedName *p) {
-    if(!p) return;
     UA_String_deleteMembers(&p->name);
 }
 
 void UA_QualifiedName_init(UA_QualifiedName *p) {
-    if(!p) return;
     UA_String_init(&p->name);
     p->namespaceIndex = 0;
 }
 
 UA_TYPE_NEW_DEFAULT(UA_QualifiedName)
 UA_StatusCode UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    retval |= UA_String_copy(&src->name, &dst->name);
+    UA_StatusCode retval = UA_String_copy(&src->name, &dst->name);
     dst->namespaceIndex = src->namespaceIndex;
-    if(retval)
+    if(retval) {
         UA_QualifiedName_deleteMembers(dst);
+        UA_QualifiedName_init(dst);
+    }
     return retval;
 
 }
@@ -659,7 +627,6 @@ UA_StatusCode UA_QualifiedName_copycstring(char const *src, UA_QualifiedName *ds
 
 #ifdef DEBUG
 void UA_QualifiedName_print(const UA_QualifiedName *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_QualifiedName){");
     UA_UInt16_print(&p->namespaceIndex, stream);
     fprintf(stream, ",");
@@ -678,45 +645,38 @@ void UA_QualifiedName_printf(char const *label, const UA_QualifiedName *qn) {
 /* LocalizedText */
 UA_TYPE_DELETE_DEFAULT(UA_LocalizedText)
 void UA_LocalizedText_deleteMembers(UA_LocalizedText *p) {
-    if(!p) return;
     UA_String_deleteMembers(&p->locale);
     UA_String_deleteMembers(&p->text);
 }
 
 void UA_LocalizedText_init(UA_LocalizedText *p) {
-    if(!p) return;
     UA_String_init(&p->locale);
     UA_String_init(&p->text);
 }
 
 UA_TYPE_NEW_DEFAULT(UA_LocalizedText)
 UA_StatusCode UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    UA_LocalizedText_init(dst);
-    retval |= UA_String_copycstring("en", &dst->locale); // TODO: Are language codes upper case?
+    UA_StatusCode retval = UA_String_copycstring("en", &dst->locale); // TODO: Are language codes upper case?
     retval |= UA_String_copycstring(src, &dst->text);
-    if(retval)
+    if(retval) {
         UA_LocalizedText_deleteMembers(dst);
+        UA_LocalizedText_init(dst);
+    }
     return retval;
 }
 
 UA_StatusCode UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst) {
-    UA_Int32 retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    UA_LocalizedText_init(dst);
-    retval |= UA_String_copy(&src->locale, &dst->locale);
+    UA_Int32 retval = UA_String_copy(&src->locale, &dst->locale);
     retval |= UA_String_copy(&src->text, &dst->text);
-    if(retval)
+    if(retval) {
         UA_LocalizedText_deleteMembers(dst);
+        UA_LocalizedText_init(dst);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_LocalizedText_print(const UA_LocalizedText *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_LocalizedText){");
     UA_String_print(&p->locale, stream);
     fprintf(stream, ",");
@@ -728,13 +688,11 @@ void UA_LocalizedText_print(const UA_LocalizedText *p, FILE *stream) {
 /* ExtensionObject */
 UA_TYPE_DELETE_DEFAULT(UA_ExtensionObject)
 void UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) {
-    if(!p) return;
     UA_NodeId_deleteMembers(&p->typeId);
     UA_ByteString_deleteMembers(&p->body);
 }
 
 void UA_ExtensionObject_init(UA_ExtensionObject *p) {
-    if(!p) return;
     UA_NodeId_init(&p->typeId);
     p->encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED;
     UA_ByteString_init(&p->body);
@@ -742,20 +700,18 @@ void UA_ExtensionObject_init(UA_ExtensionObject *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_ExtensionObject)
 UA_StatusCode UA_ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    dst->encoding = src->encoding;
-    retval |= UA_ByteString_copy(&src->body, &dst->body);
+    UA_StatusCode retval = UA_ByteString_copy(&src->body, &dst->body);
     retval |= UA_NodeId_copy(&src->typeId, &dst->typeId);
-    if(retval)
+    dst->encoding = src->encoding;
+    if(retval) {
         UA_ExtensionObject_deleteMembers(dst);
+        UA_ExtensionObject_init(dst);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_ExtensionObject_print(const UA_ExtensionObject *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_ExtensionObject){");
     UA_NodeId_print(&p->typeId, stream);
     if(p->encoding == UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING)
@@ -772,12 +728,10 @@ void UA_ExtensionObject_print(const UA_ExtensionObject *p, FILE *stream) {
 /* DataValue */
 UA_TYPE_DELETE_DEFAULT(UA_DataValue)
 void UA_DataValue_deleteMembers(UA_DataValue *p) {
-    if(!p) return;
     UA_Variant_deleteMembers(&p->value);
 }
 
 void UA_DataValue_init(UA_DataValue *p) {
-    if(!p) return;
     p->encodingMask      = 0;
     p->serverPicoseconds = 0;
     UA_DateTime_init(&p->serverTimestamp);
@@ -789,24 +743,22 @@ void UA_DataValue_init(UA_DataValue *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_DataValue)
 UA_StatusCode UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
+    UA_StatusCode retval = UA_DateTime_copy(&src->serverTimestamp, &dst->serverTimestamp);
+    retval |= UA_DateTime_copy(&src->sourceTimestamp, &dst->sourceTimestamp);
+    retval |= UA_Variant_copy(&src->value, &dst->value);
     dst->encodingMask = src->encodingMask;
     dst->serverPicoseconds = src->serverPicoseconds;
-    retval |= UA_DateTime_copy(&src->serverTimestamp, &dst->serverTimestamp);
     dst->sourcePicoseconds = src->sourcePicoseconds;
-    retval |= UA_DateTime_copy(&src->sourceTimestamp, &dst->sourceTimestamp);
     dst->status = src->status;
-    retval |= UA_Variant_copy(&src->value, &dst->value);
-    if(retval)
+    if(retval) {
         UA_DataValue_deleteMembers(dst);
+        UA_DataValue_init(dst);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_DataValue_print(const UA_DataValue *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_DataValue){");
     UA_Byte_print(&p->encodingMask, stream);
     fprintf(stream, ",");
@@ -851,7 +803,6 @@ void UA_Variant_deleteMembers(UA_Variant *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_Variant)
 void UA_Variant_init(UA_Variant *p) {
-    if(!p) return;
     p->storageType = UA_VARIANT_DATA;
     p->storage.data.arrayLength = -1;  // no element, p->data == UA_NULL
     p->storage.data.dataPtr        = UA_NULL;
@@ -860,44 +811,38 @@ void UA_Variant_init(UA_Variant *p) {
     p->vt = &UA_[UA_INVALIDTYPE];
 }
 
-/** It is not allowed to copy into a variant that points to an external data source. */
+/** This function performs a deep copy. The resulting StorageType is UA_VARIANT_DATA. */
 UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst || dst->storageType == UA_VARIANT_DATASOURCE)
-        return UA_STATUSCODE_BADINTERNALERROR;
-
+    // get the data
     UA_VariantData *dstdata = &dst->storage.data;
     const UA_VariantData *srcdata;
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
     if(src->storageType == UA_VARIANT_DATA || src->storageType == UA_VARIANT_DATA_NODELETE)
         srcdata = &src->storage.data;
     else {
         retval |= src->storage.datasource.read(src->storage.datasource.identifier, &srcdata);
-        if(retval) return retval;
+        if(retval)
+            return retval;
     }
 
-    // now copy from srcdata to dstdata.
-    dst->vt = src->vt;
+    // now copy the data to the destination
     retval |= UA_Array_copy(srcdata->dataPtr, srcdata->arrayLength, src->vt, &dstdata->dataPtr);
-    if(retval) goto clean_up;
-    dstdata->arrayLength = srcdata->arrayLength;
-    if(srcdata->arrayDimensions) {
-        retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength, &UA_[UA_INT32], (void **)&dstdata->arrayDimensions);
-        if(retval) goto clean_up2;
-        dstdata->arrayDimensionsLength = srcdata->arrayDimensionsLength;
-    }
-
-    // release the src variant if necessary
-    if(src->storageType == UA_VARIANT_DATASOURCE)
-        src->storage.datasource.release(src->storage.datasource.identifier, srcdata);
-
-    return retval;
+    if(retval == UA_STATUSCODE_GOOD) {
+        dst->storageType = UA_VARIANT_DATASOURCE;
+        dst->vt = src->vt;
+        dstdata->arrayLength = srcdata->arrayLength;
+        if(srcdata->arrayDimensions) {
+            retval |= UA_Array_copy(srcdata->arrayDimensions, srcdata->arrayDimensionsLength, &UA_[UA_INT32], (void **)&dstdata->arrayDimensions);
+            if(retval == UA_STATUSCODE_GOOD)
+                dstdata->arrayDimensionsLength = srcdata->arrayDimensionsLength;
+            else {
+                UA_Variant_deleteMembers(dst);
+                UA_Variant_init(dst);
+            }
+        }
+    } 
 
-    // clean ups are falling through to the "lower levels"
- clean_up2:
-    if(dstdata->arrayDimensions)
-        UA_Array_delete(dstdata->dataPtr, dstdata->arrayLength, src->vt);
-    
- clean_up:
+    // release the data source if necessary
     if(src->storageType == UA_VARIANT_DATASOURCE)
         src->storage.datasource.release(src->storage.datasource.identifier, srcdata);
 
@@ -906,35 +851,31 @@ 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 UA_VTable_Entry *vt, const void *value) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!v || !vt || !value)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    UA_Variant_init(v);
     v->vt = vt;
     v->storage.data.arrayLength = 1; // no array but a single entry
-    retval |= vt->new(&v->storage.data.dataPtr);
-    retval |= vt->copy(value, v->storage.data.dataPtr);
-    if(retval)
+    UA_StatusCode retval = vt->new(&v->storage.data.dataPtr);
+    if(retval == UA_STATUSCODE_GOOD)
+        retval |= vt->copy(value, v->storage.data.dataPtr);
+    if(retval) {
         UA_Variant_deleteMembers(v);
+        UA_Variant_init(v);
+    }
     return retval;
 }
-UA_StatusCode UA_Variant_copySetArray(UA_Variant *v, const UA_VTable_Entry *vt, UA_Int32 arrayLength,
-                                      const void *array) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!v || !vt || !array)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    UA_Variant_init(v);
+
+UA_StatusCode UA_Variant_copySetArray(UA_Variant *v, const UA_VTable_Entry *vt, UA_Int32 arrayLength, const void *array) {
     v->vt = vt;
     v->storage.data.arrayLength = arrayLength;
-    retval = UA_Array_copy(array, arrayLength, vt, &v->storage.data.dataPtr);
-    if(retval)
+    UA_StatusCode retval = UA_Array_copy(array, arrayLength, vt, &v->storage.data.dataPtr);
+    if(retval) {
         UA_Variant_deleteMembers(v);
+        UA_Variant_init(v);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_Variant_print(const UA_Variant *p, FILE *stream) {
-    if(!p || !stream) return;
     UA_UInt32 ns0id = UA_ns0ToVTableIndex(&p->vt->typeId);
     if(p->storageType == UA_VARIANT_DATASOURCE) {
         fprintf(stream, "Variant from a Datasource");
@@ -960,7 +901,6 @@ void UA_Variant_print(const UA_Variant *p, FILE *stream) {
 /* DiagnosticInfo */
 UA_TYPE_DELETE_DEFAULT(UA_DiagnosticInfo)
 void UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
-    if(!p) return;
     UA_String_deleteMembers(&p->additionalInfo);
     if((p->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) && p->innerDiagnosticInfo) {
         UA_DiagnosticInfo_delete(p->innerDiagnosticInfo);
@@ -969,7 +909,6 @@ void UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
 }
 
 void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
-    if(!p) return;
     UA_String_init(&p->additionalInfo);
     p->encodingMask = 0;
     p->innerDiagnosticInfo = UA_NULL;
@@ -982,11 +921,7 @@ void UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
 
 UA_TYPE_NEW_DEFAULT(UA_DiagnosticInfo)
 UA_StatusCode UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst) {
-    UA_StatusCode retval = UA_STATUSCODE_GOOD;
-    if(!src || !dst)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    UA_DiagnosticInfo_deleteMembers(dst);
-    retval |= UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
+    UA_StatusCode retval = UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
     dst->encodingMask = src->encodingMask;
     retval |= UA_StatusCode_copy(&src->innerStatusCode, &dst->innerStatusCode);
     if(src->innerDiagnosticInfo) {
@@ -999,14 +934,15 @@ UA_StatusCode UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_Diagnostic
     dst->localizedText = src->localizedText;
     dst->namespaceUri = src->namespaceUri;
     dst->symbolicId = src->symbolicId;
-    if(retval)
+    if(retval) {
         UA_DiagnosticInfo_deleteMembers(dst);
+        UA_DiagnosticInfo_init(dst);
+    }
     return retval;
 }
 
 #ifdef DEBUG
 void UA_DiagnosticInfo_print(const UA_DiagnosticInfo *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_DiagnosticInfo){");
     UA_Byte_print(&p->encodingMask, stream);
     fprintf(stream, ",");
@@ -1054,7 +990,6 @@ UA_StatusCode UA_InvalidType_new(UA_InvalidType **p) {
 
 #ifdef DEBUG
 void UA_InvalidType_print(const UA_InvalidType *p, FILE *stream) {
-    if(!p || !stream) return;
     fprintf(stream, "(UA_InvalidType){ERROR (invalid type)}");
 }
 #endif
@@ -1064,8 +999,6 @@ void UA_InvalidType_print(const UA_InvalidType *p, FILE *stream) {
 /*********/
 
 UA_StatusCode UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    if(!vt) return UA_STATUSCODE_BADINTERNALERROR;
-
     if(noElements <= 0) {
         *p = UA_NULL;
         return UA_STATUSCODE_GOOD;
@@ -1086,7 +1019,6 @@ UA_StatusCode UA_Array_new(void **p, UA_Int32 noElements, const UA_VTable_Entry
 }
 
 void UA_Array_init(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    if(!p || !vt) return;
     char *cp = (char *)p; // so compilers allow pointer arithmetic
     UA_UInt32 memSize = vt->memSize;
     for(UA_Int32 i = 0;i<noElements;i++) {
@@ -1096,8 +1028,7 @@ void UA_Array_init(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
 }
 
 void UA_Array_delete(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
-    if(!p || !vt || noElements <= 0) return;
-    char     *cp      = (char *)p; // so compilers allow pointer arithmetic
+    char *cp = (char *)p; // so compilers allow pointer arithmetic
     UA_UInt32 memSize = vt->memSize;
     for(UA_Int32 i = 0;i<noElements;i++) {
         vt->deleteMembers(cp);
@@ -1107,11 +1038,7 @@ void UA_Array_delete(void *p, UA_Int32 noElements, const UA_VTable_Entry *vt) {
 }
 
 UA_StatusCode UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTable_Entry *vt, void **dst) {
-    UA_Int32 retval;
-    if(!src || !dst || !vt)
-        return UA_STATUSCODE_BADINTERNALERROR;
-
-    retval = UA_Array_new(dst, noElements, vt);
+    UA_StatusCode retval = UA_Array_new(dst, noElements, vt);
     if(retval) {
         *dst = UA_NULL;
         return retval;
@@ -1138,7 +1065,6 @@ UA_StatusCode UA_Array_copy(const void *src, UA_Int32 noElements, const UA_VTabl
 
 #ifdef DEBUG
 void UA_Array_print(const void *p, UA_Int32 noElements, const UA_VTable_Entry *vt, FILE *stream) {
-    if(!p || !vt || !stream) return;
     fprintf(stream, "(%s){", vt->name);
     char     *cp      = (char *)p; // so compilers allow pointer arithmetic
     UA_UInt32 memSize = vt->memSize;

tests/check_builtin.c

@@ -14,208 +14,6 @@ enum UA_VARIANT_ENCODINGMASKTYPE_enum {
     UA_VARIANT_ENCODINGMASKTYPE_ARRAY       = (0x01 << 7)      // bit 7
 };
 
-START_TEST(UA_Boolean_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Boolean *arg = UA_NULL;
-	// when
-	UA_UInt32   storageSize = UA_Boolean_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, 1);
-}
-END_TEST
-
-START_TEST(UA_SByte_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_SByte *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_SByte_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 1);
-}
-END_TEST
-START_TEST(UA_Byte_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Byte  *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Byte_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 1);
-}
-END_TEST
-START_TEST(UA_Int16_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Int16 *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Int16_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 2);
-}
-END_TEST
-START_TEST(UA_UInt16_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_UInt16 *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_UInt16_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 2);
-}
-END_TEST
-START_TEST(UA_Int32_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Int32 *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Int32_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 4);
-}
-END_TEST
-START_TEST(UA_UInt32_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_UInt32 *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_UInt32_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 4);
-}
-END_TEST
-START_TEST(UA_Int64_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Int64 *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Int64_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_UInt64_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_UInt64 *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_UInt64_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_Float_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Float *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Float_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 4);
-}
-END_TEST
-START_TEST(UA_Double_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Double *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_Double_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_String_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_String *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_String_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_String));
-	ck_assert_int_ge(storageSize, sizeof(UA_Int32) + sizeof(UA_NULL));
-}
-END_TEST
-START_TEST(UA_DateTime_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_DateTime *arg = UA_NULL;
-	// when
-	UA_UInt32    storageSize = UA_DateTime_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 8);
-}
-END_TEST
-START_TEST(UA_Guid_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_Guid  *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_Guid_calcSizeBinary(arg);
-	// then
-	ck_assert_int_ge(storageSize, 16);
-}
-END_TEST
-START_TEST(UA_ByteString_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_ByteString *arg    = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_ByteString_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_ByteString));
-	ck_assert_int_ge(storageSize, sizeof(UA_Int32)+sizeof(UA_NULL));
-}
-END_TEST
-START_TEST(UA_XmlElement_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_XmlElement *arg    = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_XmlElement_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_XmlElement));
-	ck_assert_int_ge(storageSize, sizeof(UA_Int32)+sizeof(UA_NULL));
-}
-END_TEST
-START_TEST(UA_NodeId_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_NodeId *arg = UA_NULL;
-	// when
-	UA_UInt32  storageSize = UA_NodeId_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_NodeId));
-}
-END_TEST
-START_TEST(UA_ExpandedNodeId_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_ExpandedNodeId *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize  = UA_ExpandedNodeId_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_ExpandedNodeId));
-}
-END_TEST
-START_TEST(UA_StatusCode_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_StatusCode *arg    = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_StatusCode_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_StatusCode));
-}
-END_TEST
-START_TEST(UA_QualifiedName_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_QualifiedName *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_QualifiedName_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_QualifiedName));
-}
-END_TEST
-START_TEST(UA_LocalizedText_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_LocalizedText *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize = UA_LocalizedText_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_LocalizedText));
-}
-END_TEST
-START_TEST(UA_ExtensionObject_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_ExtensionObject *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize   = UA_ExtensionObject_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_ExtensionObject));
-}
-END_TEST
 START_TEST(UA_ExtensionObject_calcSizeShallWorkOnExample) {
 	// given
 	UA_Byte data[3] = { 1, 2, 3 };
@@ -258,15 +56,6 @@ START_TEST(UA_DataValue_calcSizeShallWorkOnExample) {
 	ck_assert_int_eq(size, 21);
 }
 END_TEST
-START_TEST(UA_DataValue_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_DataValue *arg = UA_NULL;
-	// when
-	UA_UInt32     storageSize = UA_DataValue_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_DataValue));
-}
-END_TEST
 START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
 	// given
 	UA_DiagnosticInfo diagnosticInfo;
@@ -281,15 +70,6 @@ START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
 	ck_assert_int_eq(UA_DiagnosticInfo_calcSizeBinary(&diagnosticInfo), 26);
 }
 END_TEST
-START_TEST(UA_DiagnosticInfo_calcSizeWithNullArgumentShallReturnStorageSize) {
-	// given
-	UA_DiagnosticInfo *arg = UA_NULL;
-	// when
-	UA_UInt32 storageSize  = UA_DiagnosticInfo_calcSizeBinary(arg);
-	// then
-	ck_assert_int_eq(storageSize, sizeof(UA_DiagnosticInfo));
-}
-END_TEST
 START_TEST(UA_String_calcSizeWithNegativLengthShallReturnEncodingSize) {
 	// given
 	UA_String arg = { -1, UA_NULL };
@@ -514,9 +294,9 @@ START_TEST(UA_Byte_decodeShallCopyAndAdvancePosition) {
 	UA_UInt32     pos    = 0;
 
 	// when
-	UA_Int32 retval = UA_Byte_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Byte_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_uint_eq(pos, 1);
 	ck_assert_uint_eq(dst, 0x08);
 }
@@ -528,9 +308,9 @@ START_TEST(UA_Byte_decodeShallModifyOnlyCurrentPosition) {
 	UA_ByteString src    = { 1, data };
 	UA_UInt32     pos    = 0;
 	// when
-	UA_Int32      retval = UA_Byte_decodeBinary(&src, &pos, &dst[1]);
+	UA_StatusCode retval = UA_Byte_decodeBinary(&src, &pos, &dst[1]);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 1);
 	ck_assert_uint_eq(dst[0], 0xFF);
 	ck_assert_uint_eq(dst[1], 0x08);
@@ -547,10 +327,10 @@ START_TEST(UA_Int16_decodeShallAssumeLittleEndian) {
 	UA_ByteString src = { 4, data };
 	// when
 	UA_Int16      val_01_00, val_00_01;
-	UA_Int32      retval = UA_Int16_decodeBinary(&src, &pos, &val_01_00);
+	UA_StatusCode retval = UA_Int16_decodeBinary(&src, &pos, &val_01_00);
 	retval |= UA_Int16_decodeBinary(&src, &pos, &val_00_01);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_01_00, 1);
 	ck_assert_int_eq(val_00_01, 256);
 	ck_assert_int_eq(pos, 4);
@@ -566,10 +346,10 @@ START_TEST(UA_Int16_decodeShallRespectSign) {
 	UA_ByteString src = { 4, data };
 	// when
 	UA_Int16      val_ff_ff, val_00_80;
-	UA_Int32      retval = UA_Int16_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_Int16_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_Int16_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_ff_ff, -1);
 	ck_assert_int_eq(val_00_80, -32768);
 }
@@ -584,10 +364,10 @@ START_TEST(UA_UInt16_decodeShallNotRespectSign) {
 	UA_ByteString src = { 4, data };
 	// when
 	UA_UInt16     val_ff_ff, val_00_80;
-	UA_Int32      retval = UA_UInt16_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_UInt16_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_UInt16_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 4);
 	ck_assert_uint_eq(val_ff_ff, (0x01 << 16)-1);
 	ck_assert_uint_eq(val_00_80, (0x01 << 15));
@@ -604,10 +384,10 @@ START_TEST(UA_Int32_decodeShallAssumeLittleEndian) {
 
 	// when
 	UA_Int32 val_01_00, val_00_01;
-	UA_Int32 retval = UA_Int32_decodeBinary(&src, &pos, &val_01_00);
+	UA_StatusCode retval = UA_Int32_decodeBinary(&src, &pos, &val_01_00);
 	retval |= UA_Int32_decodeBinary(&src, &pos, &val_00_01);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_01_00, 1);
 	ck_assert_int_eq(val_00_01, 256);
 	ck_assert_int_eq(pos, 8);
@@ -624,10 +404,10 @@ START_TEST(UA_Int32_decodeShallRespectSign) {
 
 	// when
 	UA_Int32 val_ff_ff, val_00_80;
-	UA_Int32 retval = UA_Int32_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_Int32_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_Int32_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(val_ff_ff, -1);
 	ck_assert_int_eq(val_00_80, -32768);
 }
@@ -643,10 +423,10 @@ START_TEST(UA_UInt32_decodeShallNotRespectSign) {
 
 	// when
 	UA_UInt32 val_ff_ff, val_00_80;
-	UA_Int32  retval = UA_UInt32_decodeBinary(&src, &pos, &val_ff_ff);
+	UA_StatusCode retval = UA_UInt32_decodeBinary(&src, &pos, &val_ff_ff);
 	retval |= UA_UInt32_decodeBinary(&src, &pos, &val_00_80);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert_uint_eq(val_ff_ff, (UA_UInt32)( (0x01LL << 32 ) - 1 ));
 	ck_assert_uint_eq(val_00_80, (UA_UInt32)(0x01 << 31));
@@ -692,9 +472,9 @@ START_TEST(UA_Float_decodeShallWorkOnExample) {
 	UA_ByteString src    = { 4, data };
 	UA_Float      dst;
 	// when
-	UA_Int32      retval = UA_Float_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Float_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 4);
 	ck_assert(-6.5000001 < dst);
 	ck_assert(dst < -6.49999999999);
@@ -708,9 +488,9 @@ START_TEST(UA_Double_decodeShallGiveOne) {
 	UA_ByteString src    = { 8, data };                                        // 1
 	UA_Double     dst;
 	// when
-	UA_Int32      retval = UA_Double_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Double_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert(0.9999999 < dst);
 	ck_assert(dst < 1.00000000001);
@@ -723,9 +503,9 @@ START_TEST(UA_Double_decodeShallGiveZero) {
 	UA_ByteString src    = { 8, data }; // 1
 	UA_Double     dst;
 	// when
-	UA_Int32      retval = UA_Double_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Double_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert(-0.00000001 < dst);
 	ck_assert(dst < 0.000000001);
@@ -739,9 +519,9 @@ START_TEST(UA_Double_decodeShallGiveMinusTwo) {
 
 	UA_Double     dst;
 	// when
-	UA_Int32      retval = UA_Double_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Double_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 8);
 	ck_assert(-1.9999999 > dst);
 	ck_assert(dst > -2.00000000001);
@@ -756,9 +536,9 @@ START_TEST(UA_String_decodeShallAllocateMemoryAndCopyString) {
 	UA_ByteString src    = { 16, data };
 	UA_String     dst;
 	// when
-	UA_Int32      retval = UA_String_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_String_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(dst.length, 8);
 	ck_assert_int_eq(dst.data[3], 'L');
 	// finally
@@ -774,9 +554,9 @@ START_TEST(UA_String_decodeWithNegativeSizeShallNotAllocateMemoryAndNullPtr) {
 
 	UA_String     dst;
 	// when
-	UA_Int32      retval = UA_String_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_String_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(dst.length, -1);
 	ck_assert_ptr_eq(dst.data, UA_NULL);
 }
@@ -790,9 +570,9 @@ START_TEST(UA_String_decodeWithZeroSizeShallNotAllocateMemoryAndNullPtr) {
 
 	UA_String     dst    = { 2, (UA_Byte *)"XX" };
 	// when
-	UA_Int32      retval = UA_String_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_String_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(dst.length, -1); // shall we keep zero?
 	ck_assert_ptr_eq(dst.data, UA_NULL);
 }
@@ -805,9 +585,9 @@ START_TEST(UA_NodeId_decodeTwoByteShallReadTwoBytesAndSetNamespaceToZero) {
 
 	UA_NodeId     dst;
 	// when
-	UA_Int32      retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 2);
 	ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_NUMERIC);
 	ck_assert_int_eq(dst.identifier.numeric, 16);
@@ -822,9 +602,9 @@ START_TEST(UA_NodeId_decodeFourByteShallReadFourBytesAndRespectNamespace) {
 
 	UA_NodeId     dst;
 	// when
-	UA_Int32      retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 4);
 	ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_NUMERIC);
 	ck_assert_int_eq(dst.identifier.numeric, 256);
@@ -839,9 +619,9 @@ START_TEST(UA_NodeId_decodeStringShallAllocateMemory) {
 
 	UA_NodeId     dst;
 	// when
-	UA_Int32      retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_NodeId_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 10);
 	ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_STRING);
 	ck_assert_int_eq(dst.namespaceIndex, 1);
@@ -858,9 +638,9 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
 	UA_ByteString src    = { 5, data };
 	UA_Variant    dst;
 	// when
-	UA_Int32      retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 5);
 	ck_assert_ptr_eq(dst.vt, &UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 1);
@@ -879,10 +659,10 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
 	UA_Variant    dst;
 
 	// when
-	UA_Int32 retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(pos, 1+4+2*4);
 	ck_assert_ptr_eq(dst.vt, &UA_[UA_INT32]);
 	ck_assert_int_eq(dst.storage.data.arrayLength, 2);
@@ -902,9 +682,9 @@ START_TEST(UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem) {
 
 	UA_Variant    dst;
 	// when
-	UA_Int32      retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
@@ -920,9 +700,9 @@ START_TEST(UA_Variant_decodeWithTooSmallSourceShallReturnWithError) {
 
 	UA_Variant    dst;
 	// when
-	UA_Int32      retval = UA_Variant_decodeBinary(&src, &pos, &dst);
+	UA_StatusCode retval = UA_Variant_decodeBinary(&src, &pos, &dst);
 	// then
-	ck_assert_int_ne(retval, UA_SUCCESS);
+	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_Variant_deleteMembers(&dst);
 }
@@ -945,7 +725,7 @@ START_TEST(UA_Byte_encode_test) {
 	ck_assert_uint_eq(dst.data[0], 0x08);
 	ck_assert_uint_eq(dst.data[1], 0xFF);
 	ck_assert_int_eq(pos, 1);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// Test2
 	// given
@@ -957,7 +737,7 @@ START_TEST(UA_Byte_encode_test) {
 	ck_assert_int_eq(dst.data[0], 0xFF);
 	ck_assert_int_eq(dst.data[1], 0x00);
 	ck_assert_int_eq(pos, 1);
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 }
 END_TEST
@@ -969,7 +749,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 		                      0x55,       0x55 };
 	UA_ByteString dst    = { 4, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -979,7 +759,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = -32768;
@@ -988,7 +768,7 @@ START_TEST(UA_UInt16_encodeNegativeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
@@ -998,7 +778,7 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 		                      0x55,       0x55 };
 	UA_ByteString dst    = { 4, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -1008,7 +788,7 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 32767;
@@ -1017,7 +797,7 @@ START_TEST(UA_UInt16_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
@@ -1027,7 +807,7 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 		                      0x55,       0x55, 0x55,       0x55 };
 	UA_ByteString dst    = { 8, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -1039,7 +819,7 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 0x0101FF00;
@@ -1050,7 +830,7 @@ START_TEST(UA_UInt32_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
@@ -1072,7 +852,7 @@ START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 0x7FFFFFFF;
@@ -1083,7 +863,7 @@ START_TEST(UA_Int32_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian) {
@@ -1105,7 +885,7 @@ START_TEST(UA_Int32_encodeNegativeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_UInt64_encodeShallWorkOnExample) {
@@ -1115,7 +895,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 		                      0x55,       0x55, 0x55,       0x55, 0x55,       0x55,       0x55,       0x55 };
 	UA_ByteString dst    = { 16, data };
 
-	UA_Int32      retval = 0;
+	UA_StatusCode retval = 0;
 	UA_UInt32     pos    = 0;
 
 	// when test 1
@@ -1131,7 +911,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// when test 2
 	src    = 0x7F0033AA44EE6611;
@@ -1146,7 +926,7 @@ START_TEST(UA_UInt64_encodeShallWorkOnExample) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int64_encodeShallEncodeLittleEndian) {
@@ -1172,7 +952,7 @@ START_TEST(UA_Int64_encodeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian) {
@@ -1198,7 +978,7 @@ START_TEST(UA_Int64_encodeNegativeShallEncodeLittleEndian) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_Float_encodeShallWorkOnExample) {
@@ -1218,7 +998,7 @@ START_TEST(UA_Float_encodeShallWorkOnExample) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 /*START_TEST(UA_Double_encodeShallWorkOnExample)
@@ -1239,7 +1019,7 @@ END_TEST
     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);
+    ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
    }
    END_TEST*/
 START_TEST(UA_String_encodeShallWorkOnExample) {
@@ -1268,7 +1048,7 @@ START_TEST(UA_String_encodeShallWorkOnExample) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
@@ -1298,7 +1078,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
@@ -1332,7 +1112,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
 	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);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST
 START_TEST(UA_DateTime_toStructShallWorkOnExample) {
@@ -1498,7 +1278,7 @@ END_TEST
 START_TEST(UA_ApplicationDescription_copyShallWorkOnExample) {
 	//given
 
-	UA_Int32  retval = UA_SUCCESS;
+	UA_StatusCode retval = UA_STATUSCODE_GOOD;
 	UA_String appString = (UA_String){3, (UA_Byte*)"APP"};
 	UA_String discString = (UA_String){4, (UA_Byte*)"DISC"};
 	UA_String gateWayString = (UA_String){7, (UA_Byte*)"GATEWAY"};
@@ -1520,7 +1300,7 @@ START_TEST(UA_ApplicationDescription_copyShallWorkOnExample) {
 	retval = UA_ApplicationDescription_copy(&value, &copiedValue);
 
 	//then
-	ck_assert_int_eq(retval, UA_SUCCESS);
+	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	for(UA_Int32 i = 0;i < appString.length;i++)
 		ck_assert_int_eq(copiedValue.applicationUri.data[i], value.applicationUri.data[i]);
@@ -1553,14 +1333,12 @@ START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 	// given
 	UA_String srcName = (UA_String){8, (UA_Byte*)"tEsT123!"};
 	UA_QualifiedName src = {5, srcName};
-
 	UA_QualifiedName dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_QualifiedName_copy(&src, &dst);
+	UA_StatusCode ret = UA_QualifiedName_copy(&src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq('E', dst.name.data[1]);
 	ck_assert_int_eq('!', dst.name.data[7]);
 	ck_assert_int_eq(8, dst.name.length);
@@ -1569,62 +1347,40 @@ START_TEST(UA_QualifiedName_copyShallWorkOnInputExample) {
 END_TEST
 START_TEST(UA_QualifiedName_copyNULLInput) {
 	// given
-	UA_QualifiedName *src;
-	src = UA_NULL;
-
+	UA_QualifiedName *src = UA_NULL;
 	UA_QualifiedName dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_QualifiedName_copy(src, &dst);
+	UA_StatusCode ret = UA_QualifiedName_copy(src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_ERROR);
+	ck_assert_int_eq(ret, UA_STATUSCODE_BADINTERNALERROR);
 }
 END_TEST
 START_TEST(UA_Guid_copyShallWorkOnInputExample) {
 	//given
 	const UA_Guid src = {3, 45, 1222, {8, 7, 6, 5, 4, 3, 2, 1}};
-
 	UA_Guid dst;
-	UA_Int32 ret;
 
 	//when
-	ret = UA_Guid_copy(&src, &dst);
+	UA_StatusCode ret = UA_Guid_copy(&src, &dst);
 
 	//then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(src.data1, dst.data1);
 	ck_assert_int_eq(src.data3, dst.data3);
 	ck_assert_int_eq(src.data4[4], dst.data4[4]);
 	//finally
 }
 END_TEST
-START_TEST(UA_Guid_copyWithNullArgumentShallReturn) {
-	//given
-	UA_Guid *src = UA_NULL;
-	UA_Guid *dst = UA_NULL;
-	UA_Int32 ret;
-
-	//when
-	ret = UA_Guid_copy(src, dst);
-
-	//then
-	ck_assert_int_eq(ret, UA_ERROR);
-
-	//finally
-}
-END_TEST
 START_TEST(UA_LocalizedText_copycstringShallWorkOnInputExample) {
 	// given
 	const char src[7] = {'t', 'e', 'X', 't', '1', '2', '3'};
-
 	UA_LocalizedText dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_LocalizedText_copycstring(src, &dst);
+	UA_StatusCode ret = UA_LocalizedText_copycstring(src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq('e', dst.locale.data[0]);
 	ck_assert_int_eq('n', dst.locale.data[1]);
 	ck_assert_int_eq('1', dst.text.data[4]);
@@ -1642,7 +1398,7 @@ START_TEST(UA_LocalizedText_copycstringNULLInput) {
 	// when
 	ret = UA_LocalizedText_copycstring(src, dst);
 	// then
-	ck_assert_int_eq(ret, UA_ERROR);
+	ck_assert_int_eq(ret, UA_STATUSCODE_BADINTERNALERROR);
 }
 END_TEST
 START_TEST(UA_DataValue_copyShallWorkOnInputExample) {
@@ -1650,14 +1406,12 @@ START_TEST(UA_DataValue_copyShallWorkOnInputExample) {
 	UA_Variant srcVariant;
 	UA_Variant_init(&srcVariant);
 	UA_DataValue src = {5, srcVariant, 44, 4, 77, 58, 8};
-
 	UA_DataValue dst;
-	UA_Int32 ret;
 
 	// when
-	ret = UA_DataValue_copy(&src, &dst);
+	UA_StatusCode ret = UA_DataValue_copy(&src, &dst);
 	// then
-	ck_assert_int_eq(ret, UA_SUCCESS);
+	ck_assert_int_eq(ret, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(5, dst.encodingMask);
 	ck_assert_int_eq(4, dst.sourceTimestamp);
 	ck_assert_int_eq(77, dst.sourcePicoseconds);
@@ -1805,33 +1559,9 @@ Suite *testSuite_builtin(void) {
 	Suite *s = suite_create("Built-in Data Types 62541-6 Table 1");
 
 	TCase *tc_calcSize = tcase_create("calcSize");
-	tcase_add_test(tc_calcSize, UA_Boolean_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_SByte_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Byte_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Int16_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_UInt16_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Int32_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_UInt32_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Int64_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_UInt64_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Float_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Double_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_DateTime_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_Guid_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_ByteString_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_XmlElement_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeWithNullArgumentShallReturnStorageSize);
-	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeWithNullArgumentShallReturnStorageSize);
-	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_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);
 	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNegativLengthAndValidPointerShallReturnEncodingSize);
@@ -1917,7 +1647,6 @@ Suite *testSuite_builtin(void) {
 	tcase_add_test(tc_copy, UA_ApplicationDescription_copyShallWorkOnExample);
 	tcase_add_test(tc_copy, UA_QualifiedName_copyShallWorkOnInputExample);
 	tcase_add_test(tc_copy, UA_QualifiedName_copyNULLInput);
-	tcase_add_test(tc_copy, UA_Guid_copyWithNullArgumentShallReturn);
 	tcase_add_test(tc_copy, UA_Guid_copyShallWorkOnInputExample);
 	tcase_add_test(tc_copy, UA_LocalizedText_copycstringShallWorkOnInputExample);
 	tcase_add_test(tc_copy, UA_LocalizedText_copycstringNULLInput);

tools/generate_builtin.py

@@ -250,8 +250,10 @@ UA_TYPE_METHOD_DECODEXML_NOTIMPL(%(name)s)''')
             printc('\tretval |= %(t)s_copy(&src->%(n)s,&dst->%(n)s);')
             continue
         printc("\tdst->%(n)s = src->%(n)s;")
-    printc('''if(retval)
-    %(name)s_deleteMembers(dst);''')
+    printc('''if(retval) {
+    %(name)s_deleteMembers(dst);
+    %(name)s_init(dst);
+    }''')
     printc("\treturn retval;\n}\n")
 
     # 13) Print