untabify (#766)

Command used:
`find . \( -name '*.c' -o -name '*.h' \) -not \( -path "./deps/*" -prune \) ! -type d -exec bash -c 'expand -t 4 "$0" > /tmp/e && mv /tmp/e "$0"' {} \;`

examples/server_udp.c

@@ -19,17 +19,17 @@ UA_Boolean running = 1;
 
 static void stopHandler(int sign) {
     printf("Received Ctrl-C\n");
-	running = 0;
+    running = 0;
 }
 
 int main(int argc, char** argv) {
-	signal(SIGINT, stopHandler); /* catches ctrl-c */
+    signal(SIGINT, stopHandler); /* catches ctrl-c */
 
-	UA_Server *server = UA_Server_new(UA_ServerConfig_standard);
+    UA_Server *server = UA_Server_new(UA_ServerConfig_standard);
     UA_ServerNetworkLayer *nl = ServerNetworkLayerUDP_new(UA_ConnectionConfig_standard, 16664);
     UA_Server_addNetworkLayer(server, nl);
 
-	// add a variable node to the adresspace
+    // add a variable node to the adresspace
     UA_VariableAttributes attr;
     UA_VariableAttributes_init(&attr);
     UA_Int32 myInteger = 42;
@@ -45,7 +45,7 @@ int main(int argc, char** argv) {
                               UA_NODEID_NULL, attr, NULL);
 
     UA_StatusCode retval = UA_Server_run(server, 1, &running);
-	UA_Server_delete(server);
+    UA_Server_delete(server);
 
-	return (int) retval;
+    return (int) retval;
 }

include/ua_server.h

@@ -507,7 +507,7 @@ UA_Server_browseNext(UA_Server *server, UA_Boolean releaseContinuationPoint,
  * differently) */
 typedef UA_StatusCode
 (*UA_NodeIteratorCallback)(UA_NodeId childId, UA_Boolean isInverse,
-						   UA_NodeId referenceTypeId, void *handle);
+                           UA_NodeId referenceTypeId, void *handle);
 #endif
 
 UA_StatusCode UA_EXPORT

include/ua_server_external_ns.h

@@ -81,17 +81,17 @@ typedef UA_Int32 (*UA_ExternalNodeStore_delete)(void *ensHandle);
 
 typedef struct UA_ExternalNodeStore {
     void *ensHandle;
-	UA_ExternalNodeStore_addNodes addNodes;
-	UA_ExternalNodeStore_deleteNodes deleteNodes;
-	UA_ExternalNodeStore_writeNodes writeNodes;
-	UA_ExternalNodeStore_readNodes readNodes;
-	UA_ExternalNodeStore_browseNodes browseNodes;
-	UA_ExternalNodeStore_translateBrowsePathsToNodeIds translateBrowsePathsToNodeIds;
-	UA_ExternalNodeStore_addReferences addReferences;
-	UA_ExternalNodeStore_deleteReferences deleteReferences;
-	UA_ExternalNodeStore_call call;
-	UA_ExternalNodeStore_addOneWayReference addOneWayReference;
-	UA_ExternalNodeStore_delete destroy;
+    UA_ExternalNodeStore_addNodes addNodes;
+    UA_ExternalNodeStore_deleteNodes deleteNodes;
+    UA_ExternalNodeStore_writeNodes writeNodes;
+    UA_ExternalNodeStore_readNodes readNodes;
+    UA_ExternalNodeStore_browseNodes browseNodes;
+    UA_ExternalNodeStore_translateBrowsePathsToNodeIds translateBrowsePathsToNodeIds;
+    UA_ExternalNodeStore_addReferences addReferences;
+    UA_ExternalNodeStore_deleteReferences deleteReferences;
+    UA_ExternalNodeStore_call call;
+    UA_ExternalNodeStore_addOneWayReference addOneWayReference;
+    UA_ExternalNodeStore_delete destroy;
 } UA_ExternalNodeStore;
 
 UA_StatusCode UA_EXPORT

src/server/ua_nodes.c

@@ -122,21 +122,21 @@ UA_StatusCode UA_Node_copyAnyNodeClass(const UA_Node *src, UA_Node *dst) {
         return UA_STATUSCODE_BADINTERNALERROR;
     
     /* copy standard content */
-	UA_StatusCode retval = UA_NodeId_copy(&src->nodeId, &dst->nodeId);
-	dst->nodeClass = src->nodeClass;
-	retval |= UA_QualifiedName_copy(&src->browseName, &dst->browseName);
-	retval |= UA_LocalizedText_copy(&src->displayName, &dst->displayName);
-	retval |= UA_LocalizedText_copy(&src->description, &dst->description);
-	dst->writeMask = src->writeMask;
-	dst->userWriteMask = src->userWriteMask;
-	if(retval != UA_STATUSCODE_GOOD) {
-    	UA_Node_deleteMembersAnyNodeClass(dst);
+    UA_StatusCode retval = UA_NodeId_copy(&src->nodeId, &dst->nodeId);
+    dst->nodeClass = src->nodeClass;
+    retval |= UA_QualifiedName_copy(&src->browseName, &dst->browseName);
+    retval |= UA_LocalizedText_copy(&src->displayName, &dst->displayName);
+    retval |= UA_LocalizedText_copy(&src->description, &dst->description);
+    dst->writeMask = src->writeMask;
+    dst->userWriteMask = src->userWriteMask;
+    if(retval != UA_STATUSCODE_GOOD) {
+        UA_Node_deleteMembersAnyNodeClass(dst);
         return retval;
     }
-	retval |= UA_Array_copy(src->references, src->referencesSize, (void**)&dst->references,
+    retval |= UA_Array_copy(src->references, src->referencesSize, (void**)&dst->references,
                             &UA_TYPES[UA_TYPES_REFERENCENODE]);
-	if(retval != UA_STATUSCODE_GOOD) {
-    	UA_Node_deleteMembersAnyNodeClass(dst);
+    if(retval != UA_STATUSCODE_GOOD) {
+        UA_Node_deleteMembersAnyNodeClass(dst);
         return retval;
     }
     dst->referencesSize = src->referencesSize;
@@ -170,7 +170,7 @@ UA_StatusCode UA_Node_copyAnyNodeClass(const UA_Node *src, UA_Node *dst) {
     default:
         break;
     }
-	if(retval != UA_STATUSCODE_GOOD)
-    	UA_Node_deleteMembersAnyNodeClass(dst);
+    if(retval != UA_STATUSCODE_GOOD)
+        UA_Node_deleteMembersAnyNodeClass(dst);
     return retval;
 }

src/server/ua_nodestore.h

@@ -37,21 +37,21 @@ void UA_NodeStore_delete(UA_NodeStore *ns);
 /* Create an editable node of the given NodeClass. */
 UA_Node * UA_NodeStore_newNode(UA_NodeClass nodeClass);
 #define UA_NodeStore_newObjectNode() \
-	(UA_ObjectNode*)UA_NodeStore_newNode(UA_NODECLASS_OBJECT)
+    (UA_ObjectNode*)UA_NodeStore_newNode(UA_NODECLASS_OBJECT)
 #define UA_NodeStore_newVariableNode() \
-	(UA_VariableNode*)UA_NodeStore_newNode(UA_NODECLASS_VARIABLE)
+    (UA_VariableNode*)UA_NodeStore_newNode(UA_NODECLASS_VARIABLE)
 #define UA_NodeStore_newMethodNode() \
-	(UA_MethodNode*)UA_NodeStore_newNode(UA_NODECLASS_METHOD)
+    (UA_MethodNode*)UA_NodeStore_newNode(UA_NODECLASS_METHOD)
 #define UA_NodeStore_newObjectTypeNode() \
-	(UA_ObjectTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_OBJECTTYPE)
+    (UA_ObjectTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_OBJECTTYPE)
 #define UA_NodeStore_newVariableTypeNode() \
-	(UA_VariableTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_VARIABLETYPE)
+    (UA_VariableTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_VARIABLETYPE)
 #define UA_NodeStore_newReferenceTypeNode() \
-	(UA_ReferenceTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_REFERENCETYPE)
+    (UA_ReferenceTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_REFERENCETYPE)
 #define UA_NodeStore_newDataTypeNode() \
-	(UA_DataTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_DATATYPE)
+    (UA_DataTypeNode*)UA_NodeStore_newNode(UA_NODECLASS_DATATYPE)
 #define UA_NodeStore_newViewNode() \
-	(UA_ViewNode*)UA_NodeStore_newNode(UA_NODECLASS_VIEW)
+    (UA_ViewNode*)UA_NodeStore_newNode(UA_NODECLASS_VIEW)
 
 /* Delete an editable node. */
 void UA_NodeStore_deleteNode(UA_Node *node);

src/server/ua_services_call.c

@@ -160,11 +160,11 @@ Service_Call_single(UA_Server *server, UA_Session *session, const UA_CallMethodR
     for(size_t i=0;i<methodCalled->referencesSize;i++){
         if (methodCalled->references[i].isInverse && UA_NodeId_equal(&methodCalled->references[i].targetId.nodeId,&withObject->nodeId)){
             //TODO adjust maxDepth to needed tree depth (define a variable in config?)
-    	    isNodeInTree(server->nodestore, &methodCalled->references[i].referenceTypeId, &hasComponentNodeId,
-    	         &hasSubTypeNodeId, 1, 1, &found);
+            isNodeInTree(server->nodestore, &methodCalled->references[i].referenceTypeId, &hasComponentNodeId,
+                 &hasSubTypeNodeId, 1, 1, &found);
             if(found){
                 break;
-    	    }
+            }
         }
     }
     if(!found)
@@ -250,13 +250,13 @@ void Service_Call(UA_Server *server, UA_Session *session, const UA_CallRequest *
                        indices, (UA_UInt32)indexSize, response->results);
     }
 #endif
-	
+    
     for(size_t i = 0; i < request->methodsToCallSize;i++){
 #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
         if(!isExternal[i])
 #endif    
-			Service_Call_single(server, session, &request->methodsToCall[i], &response->results[i]);
-	}
+            Service_Call_single(server, session, &request->methodsToCall[i], &response->results[i]);
+    }
 }
 
 #endif /* UA_ENABLE_METHODCALLS */

tests/check_nodestore.c

@@ -15,246 +15,246 @@
 int zeroCnt = 0;
 int visitCnt = 0;
 static void checkZeroVisitor(const UA_Node* node) {
-	visitCnt++;
-	if (node == NULL) zeroCnt++;
+    visitCnt++;
+    if (node == NULL) zeroCnt++;
 }
 
 static void printVisitor(const UA_Node* node) {
-	printf("%d\n", node->nodeId.identifier.numeric);
+    printf("%d\n", node->nodeId.identifier.numeric);
 }
 
 static UA_Node* createNode(UA_Int16 nsid, UA_Int32 id) {
-	UA_Node *p = (UA_Node *)UA_NodeStore_newVariableNode();
-	p->nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
-	p->nodeId.namespaceIndex = nsid;
-	p->nodeId.identifier.numeric = id;
-	p->nodeClass = UA_NODECLASS_VARIABLE;
-	return p;
+    UA_Node *p = (UA_Node *)UA_NodeStore_newVariableNode();
+    p->nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
+    p->nodeId.namespaceIndex = nsid;
+    p->nodeId.identifier.numeric = id;
+    p->nodeClass = UA_NODECLASS_VARIABLE;
+    return p;
 }
 
 START_TEST(replaceExistingNode) {
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n1 = createNode(0,2253);
-	UA_NodeStore_insert(ns, n1);
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n1 = createNode(0,2253);
+    UA_NodeStore_insert(ns, n1);
     UA_NodeId in1 = UA_NODEID_NUMERIC(0, 2253);
-	UA_Node* n2 = UA_NodeStore_getCopy(ns, &in1);
+    UA_Node* n2 = UA_NodeStore_getCopy(ns, &in1);
     UA_StatusCode retval = UA_NodeStore_replace(ns, n2);
     
-	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
     
-	UA_NodeStore_delete(ns);
+    UA_NodeStore_delete(ns);
 }
 END_TEST
 
 START_TEST(replaceOldNode) {
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n1 = createNode(0,2253);
-	UA_NodeStore_insert(ns, n1);
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n1 = createNode(0,2253);
+    UA_NodeStore_insert(ns, n1);
     UA_NodeId in1 = UA_NODEID_NUMERIC(0,2253);
-	UA_Node* n2 = UA_NodeStore_getCopy(ns, &in1);
-	UA_Node* n3 = UA_NodeStore_getCopy(ns, &in1);
+    UA_Node* n2 = UA_NodeStore_getCopy(ns, &in1);
+    UA_Node* n3 = UA_NodeStore_getCopy(ns, &in1);
 
     /* shall succeed */
     UA_StatusCode retval = UA_NodeStore_replace(ns, n2);
-	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
+    ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
     /* shall fail */
     retval = UA_NodeStore_replace(ns, n3);
-	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
+    ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
     
-	UA_NodeStore_delete(ns);
+    UA_NodeStore_delete(ns);
 }
 END_TEST
 
 START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n1 = createNode(0,2253);
-	UA_NodeStore_insert(ns, n1);
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n1 = createNode(0,2253);
+    UA_NodeStore_insert(ns, n1);
     UA_NodeId in1 = UA_NODEID_NUMERIC(0,2253);
-	const UA_Node* nr = UA_NodeStore_get(ns, &in1);
-	// then
-	ck_assert_int_eq((uintptr_t)n1, (uintptr_t)nr);
-	// finally
-	UA_NodeStore_delete(ns);
+    const UA_Node* nr = UA_NodeStore_get(ns, &in1);
+    // then
+    ck_assert_int_eq((uintptr_t)n1, (uintptr_t)nr);
+    // finally
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 START_TEST(failToFindNodeInOtherUA_NodeStore) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
 
-	UA_Node* n1 = createNode(0,2255);
+    UA_Node* n1 = createNode(0,2255);
     UA_NodeStore_insert(ns, n1);
 
-	// when
-	UA_NodeId in1 = UA_NODEID_NUMERIC(1, 2255);
-	const UA_Node* nr = UA_NodeStore_get(ns, &in1);
-	// then
-	ck_assert_int_eq((uintptr_t)nr, 0);
-	// finally
-	UA_NodeStore_delete(ns);
+    // when
+    UA_NodeId in1 = UA_NODEID_NUMERIC(1, 2255);
+    const UA_Node* nr = UA_NodeStore_get(ns, &in1);
+    // then
+    ck_assert_int_eq((uintptr_t)nr, 0);
+    // finally
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 START_TEST(findNodeInUA_NodeStoreWithSeveralEntries) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n1 = createNode(0,2253);
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n1 = createNode(0,2253);
     UA_NodeStore_insert(ns, n1);
-	UA_Node* n2 = createNode(0,2255);
+    UA_Node* n2 = createNode(0,2255);
     UA_NodeStore_insert(ns, n2);
-	UA_Node* n3 = createNode(0,2257);
+    UA_Node* n3 = createNode(0,2257);
     UA_NodeStore_insert(ns, n3);
-	UA_Node* n4 = createNode(0,2200);
+    UA_Node* n4 = createNode(0,2200);
     UA_NodeStore_insert(ns, n4);
-	UA_Node* n5 = createNode(0,1);
+    UA_Node* n5 = createNode(0,1);
     UA_NodeStore_insert(ns, n5);
-	UA_Node* n6 = createNode(0,12);
+    UA_Node* n6 = createNode(0,12);
     UA_NodeStore_insert(ns, n6);
 
-	// when
+    // when
     UA_NodeId in3 = UA_NODEID_NUMERIC(0, 2257);
-	const UA_Node* nr = UA_NodeStore_get(ns, &in3);
-	// then
-	ck_assert_int_eq((uintptr_t)nr, (uintptr_t)n3);
-	// finally
-	UA_NodeStore_delete(ns);
+    const UA_Node* nr = UA_NodeStore_get(ns, &in3);
+    // then
+    ck_assert_int_eq((uintptr_t)nr, (uintptr_t)n3);
+    // finally
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 START_TEST(iterateOverUA_NodeStoreShallNotVisitEmptyNodes) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n1 = createNode(0,2253);
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n1 = createNode(0,2253);
     UA_NodeStore_insert(ns, n1);
-	UA_Node* n2 = createNode(0,2255);
+    UA_Node* n2 = createNode(0,2255);
     UA_NodeStore_insert(ns, n2);
-	UA_Node* n3 = createNode(0,2257);
+    UA_Node* n3 = createNode(0,2257);
     UA_NodeStore_insert(ns, n3);
-	UA_Node* n4 = createNode(0,2200);
+    UA_Node* n4 = createNode(0,2200);
     UA_NodeStore_insert(ns, n4);
-	UA_Node* n5 = createNode(0,1);
+    UA_Node* n5 = createNode(0,1);
     UA_NodeStore_insert(ns, n5);
-	UA_Node* n6 = createNode(0,12);
+    UA_Node* n6 = createNode(0,12);
     UA_NodeStore_insert(ns, n6);
 
-	// when
-	zeroCnt = 0;
-	visitCnt = 0;
-	UA_NodeStore_iterate(ns,checkZeroVisitor);
-	// then
-	ck_assert_int_eq(zeroCnt, 0);
-	ck_assert_int_eq(visitCnt, 6);
-	// finally
-	UA_NodeStore_delete(ns);
+    // when
+    zeroCnt = 0;
+    visitCnt = 0;
+    UA_NodeStore_iterate(ns,checkZeroVisitor);
+    // then
+    ck_assert_int_eq(zeroCnt, 0);
+    ck_assert_int_eq(visitCnt, 6);
+    // finally
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 START_TEST(findNodeInExpandedNamespace) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n;
-	UA_Int32 i=0;
-	for (; i<200; i++) {
-		n = createNode(0,i);
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n;
+    UA_Int32 i=0;
+    for (; i<200; i++) {
+        n = createNode(0,i);
         UA_NodeStore_insert(ns, n);
-	}
-	// when
-	UA_Node *n2 = createNode(0,25);
-	const UA_Node* nr = UA_NodeStore_get(ns,&n2->nodeId);
-	// then
-	ck_assert_int_eq(nr->nodeId.identifier.numeric,n2->nodeId.identifier.numeric);
-	// finally
+    }
+    // when
+    UA_Node *n2 = createNode(0,25);
+    const UA_Node* nr = UA_NodeStore_get(ns,&n2->nodeId);
+    // then
+    ck_assert_int_eq(nr->nodeId.identifier.numeric,n2->nodeId.identifier.numeric);
+    // finally
     UA_NodeStore_deleteNode(n2);
-	UA_NodeStore_delete(ns);
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 START_TEST(iterateOverExpandedNamespaceShallNotVisitEmptyNodes) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
     UA_Node* n;
-	UA_Int32 i=0;
-	for (; i<200; i++) {
-		n = createNode(0,i);
+    UA_Int32 i=0;
+    for (; i<200; i++) {
+        n = createNode(0,i);
         UA_NodeStore_insert(ns, n);
-	}
-	// when
-	zeroCnt = 0;
-	visitCnt = 0;
-	UA_NodeStore_iterate(ns,checkZeroVisitor);
-	// then
-	ck_assert_int_eq(zeroCnt, 0);
-	ck_assert_int_eq(visitCnt, 200);
-	// finally
-	UA_NodeStore_delete(ns);
+    }
+    // when
+    zeroCnt = 0;
+    visitCnt = 0;
+    UA_NodeStore_iterate(ns,checkZeroVisitor);
+    // then
+    ck_assert_int_eq(zeroCnt, 0);
+    ck_assert_int_eq(visitCnt, 200);
+    // finally
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 START_TEST(failToFindNonExistantNodeInUA_NodeStoreWithSeveralEntries) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
-	// given
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node* n1 = createNode(0,2253);
+    // given
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node* n1 = createNode(0,2253);
     UA_NodeStore_insert(ns, n1);
-	UA_Node* n2 = createNode(0,2255);
+    UA_Node* n2 = createNode(0,2255);
     UA_NodeStore_insert(ns, n2);
-	UA_Node* n3 = createNode(0,2257);
+    UA_Node* n3 = createNode(0,2257);
     UA_NodeStore_insert(ns, n3);
-	UA_Node* n4 = createNode(0,2200);
+    UA_Node* n4 = createNode(0,2200);
     UA_NodeStore_insert(ns, n4);
-	UA_Node* n5 = createNode(0,1);
+    UA_Node* n5 = createNode(0,1);
     UA_NodeStore_insert(ns, n5);
 
     UA_NodeId id = UA_NODEID_NUMERIC(0, 12);
 
-	// when
-	const UA_Node* nr = UA_NodeStore_get(ns, &id);
-	// then
-	ck_assert_int_eq((uintptr_t)nr, 0);
-	// finally
-	UA_NodeStore_delete(ns);
+    // when
+    const UA_Node* nr = UA_NodeStore_get(ns, &id);
+    // then
+    ck_assert_int_eq((uintptr_t)nr, 0);
+    // finally
+    UA_NodeStore_delete(ns);
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
@@ -265,114 +265,114 @@ END_TEST
 
 #ifdef UA_ENABLE_MULTITHREADING
 struct UA_NodeStoreProfileTest {
-	UA_NodeStore *ns;
-	UA_Int32 min_val;
-	UA_Int32 max_val;
-	UA_Int32 rounds;
+    UA_NodeStore *ns;
+    UA_Int32 min_val;
+    UA_Int32 max_val;
+    UA_Int32 rounds;
 };
 
 static void *profileGetThread(void *arg) {
-   	rcu_register_thread();
-	struct UA_NodeStoreProfileTest *test = (struct UA_NodeStoreProfileTest*) arg;
-	UA_NodeId id;
+    rcu_register_thread();
+    struct UA_NodeStoreProfileTest *test = (struct UA_NodeStoreProfileTest*) arg;
+    UA_NodeId id;
     UA_NodeId_init(&id);
-	UA_Int32 max_val = test->max_val;
-	UA_NodeStore *ns = test->ns;
-	for(UA_Int32 x = 0; x<test->rounds; x++) {
-		for(UA_Int32 i=test->min_val; i<max_val; i++) {
-			id.identifier.numeric = i;
-			UA_NodeStore_get(ns,&id);
-		}
-	}
-	rcu_unregister_thread();
-	
-	return NULL;
+    UA_Int32 max_val = test->max_val;
+    UA_NodeStore *ns = test->ns;
+    for(UA_Int32 x = 0; x<test->rounds; x++) {
+        for(UA_Int32 i=test->min_val; i<max_val; i++) {
+            id.identifier.numeric = i;
+            UA_NodeStore_get(ns,&id);
+        }
+    }
+    rcu_unregister_thread();
+    
+    return NULL;
 }
 #endif
 
 START_TEST(profileGetDelete) {
 #ifdef UA_ENABLE_MULTITHREADING
-   	rcu_register_thread();
+    rcu_register_thread();
 #endif
 
 #define N 1000000
-	UA_NodeStore *ns = UA_NodeStore_new();
-	UA_Node *n;
-	for (int i=0; i<N; i++) {
-		n = createNode(0,i);
+    UA_NodeStore *ns = UA_NodeStore_new();
+    UA_Node *n;
+    for (int i=0; i<N; i++) {
+        n = createNode(0,i);
         UA_NodeStore_insert(ns, n);
-	}
-	clock_t begin, end;
-	begin = clock();
+    }
+    clock_t begin, end;
+    begin = clock();
 #ifdef UA_ENABLE_MULTITHREADING
 #define THREADS 4
     pthread_t t[THREADS];
-	struct UA_NodeStoreProfileTest p[THREADS];
-	for (int i = 0; i < THREADS; i++) {
-		p[i] = (struct UA_NodeStoreProfileTest){ns, i*(N/THREADS), (i+1)*(N/THREADS), 50};
-		pthread_create(&t[i], NULL, profileGetThread, &p[i]);
-	}
-	for (int i = 0; i < THREADS; i++)
-		pthread_join(t[i], NULL);
-	end = clock();
-	printf("Time for %d create/get/delete on %d threads in a namespace: %fs.\n", N, THREADS, (double)(end - begin) / CLOCKS_PER_SEC);
+    struct UA_NodeStoreProfileTest p[THREADS];
+    for (int i = 0; i < THREADS; i++) {
+        p[i] = (struct UA_NodeStoreProfileTest){ns, i*(N/THREADS), (i+1)*(N/THREADS), 50};
+        pthread_create(&t[i], NULL, profileGetThread, &p[i]);
+    }
+    for (int i = 0; i < THREADS; i++)
+        pthread_join(t[i], NULL);
+    end = clock();
+    printf("Time for %d create/get/delete on %d threads in a namespace: %fs.\n", N, THREADS, (double)(end - begin) / CLOCKS_PER_SEC);
 #else
-	UA_NodeId id;
+    UA_NodeId id;
     UA_NodeId_init(&id);
-	for(UA_Int32 x = 0; x<50; x++) {
-	    for(int i=0; i<N; i++) {
-	        id.identifier.numeric = i;
+    for(UA_Int32 x = 0; x<50; x++) {
+        for(int i=0; i<N; i++) {
+            id.identifier.numeric = i;
             UA_NodeStore_get(ns,&id);
         }
     }
-	end = clock();
-	printf("Time for single-threaded %d create/get/delete in a namespace: %fs.\n", N, (double)(end - begin) / CLOCKS_PER_SEC);
+    end = clock();
+    printf("Time for single-threaded %d create/get/delete in a namespace: %fs.\n", N, (double)(end - begin) / CLOCKS_PER_SEC);
 #endif
 
-	UA_NodeStore_delete(ns);
+    UA_NodeStore_delete(ns);
 
 #ifdef UA_ENABLE_MULTITHREADING
-	rcu_unregister_thread();
+    rcu_unregister_thread();
 #endif
 }
 END_TEST
 
 static Suite * namespace_suite (void) {
-	Suite *s = suite_create ("UA_NodeStore");
-
-	TCase* tc_find = tcase_create ("Find");
-	tcase_add_test (tc_find, findNodeInUA_NodeStoreWithSingleEntry);
-	tcase_add_test (tc_find, findNodeInUA_NodeStoreWithSeveralEntries);
-	tcase_add_test (tc_find, findNodeInExpandedNamespace);
-	tcase_add_test (tc_find, failToFindNonExistantNodeInUA_NodeStoreWithSeveralEntries);
-	tcase_add_test (tc_find, failToFindNodeInOtherUA_NodeStore);
-	suite_add_tcase (s, tc_find);
-
-	TCase *tc_replace = tcase_create("Replace");
-	tcase_add_test (tc_replace, replaceExistingNode);
-	tcase_add_test (tc_replace, replaceOldNode);
-	suite_add_tcase (s, tc_replace);
-
-	TCase* tc_iterate = tcase_create ("Iterate");
-	tcase_add_test (tc_iterate, iterateOverUA_NodeStoreShallNotVisitEmptyNodes);
-	tcase_add_test (tc_iterate, iterateOverExpandedNamespaceShallNotVisitEmptyNodes);
-	suite_add_tcase (s, tc_iterate);
-	
-	/* TCase* tc_profile = tcase_create ("Profile"); */
-	/* tcase_add_test (tc_profile, profileGetDelete); */
-	/* suite_add_tcase (s, tc_profile); */
-
-	return s;
+    Suite *s = suite_create ("UA_NodeStore");
+
+    TCase* tc_find = tcase_create ("Find");
+    tcase_add_test (tc_find, findNodeInUA_NodeStoreWithSingleEntry);
+    tcase_add_test (tc_find, findNodeInUA_NodeStoreWithSeveralEntries);
+    tcase_add_test (tc_find, findNodeInExpandedNamespace);
+    tcase_add_test (tc_find, failToFindNonExistantNodeInUA_NodeStoreWithSeveralEntries);
+    tcase_add_test (tc_find, failToFindNodeInOtherUA_NodeStore);
+    suite_add_tcase (s, tc_find);
+
+    TCase *tc_replace = tcase_create("Replace");
+    tcase_add_test (tc_replace, replaceExistingNode);
+    tcase_add_test (tc_replace, replaceOldNode);
+    suite_add_tcase (s, tc_replace);
+
+    TCase* tc_iterate = tcase_create ("Iterate");
+    tcase_add_test (tc_iterate, iterateOverUA_NodeStoreShallNotVisitEmptyNodes);
+    tcase_add_test (tc_iterate, iterateOverExpandedNamespaceShallNotVisitEmptyNodes);
+    suite_add_tcase (s, tc_iterate);
+    
+    /* TCase* tc_profile = tcase_create ("Profile"); */
+    /* tcase_add_test (tc_profile, profileGetDelete); */
+    /* suite_add_tcase (s, tc_profile); */
+
+    return s;
 }
 
 
 int main (void) {
-	int number_failed = 0;
-	Suite *s = namespace_suite();
-	SRunner *sr = srunner_create(s);
-	srunner_set_fork_status(sr,CK_NOFORK);
-	srunner_run_all(sr, CK_NORMAL);
-	number_failed += srunner_ntests_failed (sr);
-	srunner_free(sr);
-	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+    int number_failed = 0;
+    Suite *s = namespace_suite();
+    SRunner *sr = srunner_create(s);
+    srunner_set_fork_status(sr,CK_NOFORK);
+    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_server_userspace.c

@@ -21,27 +21,27 @@ START_TEST(Server_addNamespace_ShallWork)
 END_TEST
 
 static Suite* testSuite_ServerUserspace(void) {
-	Suite *s = suite_create("ServerUserspace");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, Server_addNamespace_ShallWork);
+    Suite *s = suite_create("ServerUserspace");
+    TCase *tc_core = tcase_create("Core");
+    tcase_add_test(tc_core, Server_addNamespace_ShallWork);
 
-	suite_add_tcase(s,tc_core);
-	return s;
+    suite_add_tcase(s,tc_core);
+    return s;
 }
 
 int main(void) {
-	int number_failed = 0;
+    int number_failed = 0;
 
-	Suite *s;
-	SRunner *sr;
+    Suite *s;
+    SRunner *sr;
 
-	s = testSuite_ServerUserspace();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
+    s = testSuite_ServerUserspace();
+    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;
+    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }
 
 

tests/check_services_attributes.c

@@ -1037,83 +1037,83 @@ START_TEST(numericRange) {
 } END_TEST
 
 static Suite * testSuite_services_attributes(void) {
-	Suite *s = suite_create("services_attributes_read");
-
-	TCase *tc_readSingleAttributes = tcase_create("readSingleAttributes");
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeValueWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeValueRangeWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeNodeIdWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeNodeClassWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeBrowseNameWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeDisplayNameWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeDescriptionWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeWriteMaskWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeUserWriteMaskWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeIsAbstractWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeSymmetricWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeInverseNameWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeContainsNoLoopsWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeEventNotifierWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeDataTypeWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeValueRankWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeArrayDimensionsWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeAccessLevelWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeUserAccessLevelWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeMinimumSamplingIntervalWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeHistorizingWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeExecutableWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeUserExecutableWithoutTimestamp);
+    Suite *s = suite_create("services_attributes_read");
+
+    TCase *tc_readSingleAttributes = tcase_create("readSingleAttributes");
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeValueWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeValueRangeWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeNodeIdWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeNodeClassWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeBrowseNameWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeDisplayNameWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeDescriptionWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeWriteMaskWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeUserWriteMaskWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeIsAbstractWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeSymmetricWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeInverseNameWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeContainsNoLoopsWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeEventNotifierWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeDataTypeWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeValueRankWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeArrayDimensionsWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeAccessLevelWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeUserAccessLevelWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeMinimumSamplingIntervalWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeHistorizingWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeExecutableWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleAttributeUserExecutableWithoutTimestamp);
         tcase_add_test(tc_readSingleAttributes, ReadSingleDataSourceAttributeDataTypeWithoutTimestampFromBrokenSource);
         tcase_add_test(tc_readSingleAttributes, ReadSingleDataSourceAttributeValueWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleDataSourceAttributeDataTypeWithoutTimestamp);
-	tcase_add_test(tc_readSingleAttributes, ReadSingleDataSourceAttributeArrayDimensionsWithoutTimestamp);
-
-	suite_add_tcase(s, tc_readSingleAttributes);
-
-	TCase *tc_writeSingleAttributes = tcase_create("writeSingleAttributes");
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeNodeId);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeNodeclass);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeBrowseName);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeDisplayName);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeDescription);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeWriteMask);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeUserWriteMask);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeIsAbstract);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeSymmetric);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeInverseName);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeContainsNoLoops);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeEventNotifier);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeValue);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeDataType);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeValueRank);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeArrayDimensions);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeAccessLevel);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeUserAccessLevel);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeMinimumSamplingInterval);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeHistorizing);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeExecutable);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeUserExecutable);
-	tcase_add_test(tc_writeSingleAttributes, WriteSingleDataSourceAttributeValue);
-
-	suite_add_tcase(s, tc_writeSingleAttributes);
-
-	TCase *tc_parseNumericRange = tcase_create("parseNumericRange");
-	tcase_add_test(tc_parseNumericRange, numericRange);
-	suite_add_tcase(s, tc_parseNumericRange);
-
-	return s;
+    tcase_add_test(tc_readSingleAttributes, ReadSingleDataSourceAttributeDataTypeWithoutTimestamp);
+    tcase_add_test(tc_readSingleAttributes, ReadSingleDataSourceAttributeArrayDimensionsWithoutTimestamp);
+
+    suite_add_tcase(s, tc_readSingleAttributes);
+
+    TCase *tc_writeSingleAttributes = tcase_create("writeSingleAttributes");
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeNodeId);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeNodeclass);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeBrowseName);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeDisplayName);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeDescription);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeWriteMask);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeUserWriteMask);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeIsAbstract);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeSymmetric);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeInverseName);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeContainsNoLoops);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeEventNotifier);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeValue);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeDataType);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeValueRank);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeArrayDimensions);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeAccessLevel);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeUserAccessLevel);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeMinimumSamplingInterval);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeHistorizing);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeExecutable);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleAttributeUserExecutable);
+    tcase_add_test(tc_writeSingleAttributes, WriteSingleDataSourceAttributeValue);
+
+    suite_add_tcase(s, tc_writeSingleAttributes);
+
+    TCase *tc_parseNumericRange = tcase_create("parseNumericRange");
+    tcase_add_test(tc_parseNumericRange, numericRange);
+    suite_add_tcase(s, tc_parseNumericRange);
+
+    return s;
 }
 
 int main(void) {
 
-	int number_failed = 0;
-	Suite *s;
-	s = testSuite_services_attributes();
-	SRunner *sr = srunner_create(s);
-	srunner_set_fork_status(sr, CK_NOFORK);
-	srunner_run_all(sr, CK_NORMAL);
+    int number_failed = 0;
+    Suite *s;
+    s = testSuite_services_attributes();
+    SRunner *sr = srunner_create(s);
+    srunner_set_fork_status(sr, CK_NOFORK);
+    srunner_run_all(sr, CK_NORMAL);
 
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+    number_failed += srunner_ntests_failed(sr);
+    srunner_free(sr);
+    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }

tests/check_services_nodemanagement.c

@@ -88,25 +88,25 @@ START_TEST(AddNodeTwiceGivesError) {
 } END_TEST
 
 static Suite * testSuite_services_nodemanagement(void) {
-	Suite *s = suite_create("services_nodemanagement");
+    Suite *s = suite_create("services_nodemanagement");
 
-	TCase *tc_addnodes = tcase_create("addnodes");
-	tcase_add_test(tc_addnodes, AddVariableNode);
+    TCase *tc_addnodes = tcase_create("addnodes");
+    tcase_add_test(tc_addnodes, AddVariableNode);
         tcase_add_test(tc_addnodes, AddComplexTypeWithInheritance);
-	tcase_add_test(tc_addnodes, AddNodeTwiceGivesError);
+    tcase_add_test(tc_addnodes, AddNodeTwiceGivesError);
 
-	suite_add_tcase(s, tc_addnodes);
-	return s;
+    suite_add_tcase(s, tc_addnodes);
+    return s;
 }
 
 int main(void) {
-	int number_failed = 0;
-	Suite *s;
-	s = testSuite_services_nodemanagement();
-	SRunner *sr = srunner_create(s);
-	srunner_set_fork_status(sr, CK_NOFORK);
-	srunner_run_all(sr, CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
-	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+    int number_failed = 0;
+    Suite *s;
+    s = testSuite_services_nodemanagement();
+    SRunner *sr = srunner_create(s);
+    srunner_set_fork_status(sr, CK_NOFORK);
+    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_services_view.c

@@ -7,47 +7,47 @@
 
 /* START_TEST(Service_TranslateBrowsePathsToNodeIds_SmokeTest)
 {
-	UA_TranslateBrowsePathsToNodeIdsRequest request;
-	UA_TranslateBrowsePathsToNodeIdsRequest_init(&request);
+    UA_TranslateBrowsePathsToNodeIdsRequest request;
+    UA_TranslateBrowsePathsToNodeIdsRequest_init(&request);
 
-	UA_TranslateBrowsePathsToNodeIdsResponse response;
-	UA_TranslateBrowsePathsToNodeIdsResponse_init(&response);
+    UA_TranslateBrowsePathsToNodeIdsResponse response;
+    UA_TranslateBrowsePathsToNodeIdsResponse_init(&response);
 
-	request.browsePathsSize = 1;
-	UA_Array_new((void**)&request.browsePaths,request.browsePathsSize, &UA_.types[UA_BROWSEPATH]);
+    request.browsePathsSize = 1;
+    UA_Array_new((void**)&request.browsePaths,request.browsePathsSize, &UA_.types[UA_BROWSEPATH]);
 
-	Service_TranslateBrowsePathsToNodeIds(NULL,&request,&response);
+    Service_TranslateBrowsePathsToNodeIds(NULL,&request,&response);
 
-	ck_assert_int_eq(response.resultsSize,request.browsePathsSize);
-	ck_assert_int_eq(response.results[0].statusCode,UA_STATUSCODE_BADNOMATCH);
+    ck_assert_int_eq(response.resultsSize,request.browsePathsSize);
+    ck_assert_int_eq(response.results[0].statusCode,UA_STATUSCODE_BADNOMATCH);
 
-	//finally
-	UA_TranslateBrowsePathsToNodeIdsRequest_deleteMembers(&request);
-	UA_TranslateBrowsePathsToNodeIdsResponse_deleteMembers(&response);
+    //finally
+    UA_TranslateBrowsePathsToNodeIdsRequest_deleteMembers(&request);
+    UA_TranslateBrowsePathsToNodeIdsResponse_deleteMembers(&response);
 }
 END_TEST */
 
 static Suite* testSuite_Service_TranslateBrowsePathsToNodeIds(void) {
-	Suite *s = suite_create("Service_TranslateBrowsePathsToNodeIds");
-	TCase *tc_core = tcase_create("Core");
-	//tcase_add_test(tc_core, Service_TranslateBrowsePathsToNodeIds_SmokeTest);
-	suite_add_tcase(s,tc_core);
-	return s;
+    Suite *s = suite_create("Service_TranslateBrowsePathsToNodeIds");
+    TCase *tc_core = tcase_create("Core");
+    //tcase_add_test(tc_core, Service_TranslateBrowsePathsToNodeIds_SmokeTest);
+    suite_add_tcase(s,tc_core);
+    return s;
 }
 
 int main(void) {
-	int number_failed = 0;
+    int number_failed = 0;
 
-	Suite *s;
-	SRunner *sr;
+    Suite *s;
+    SRunner *sr;
 
-	s = testSuite_Service_TranslateBrowsePathsToNodeIds();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
+    s = testSuite_Service_TranslateBrowsePathsToNodeIds();
+    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;
+    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }
 
 

tests/check_session.c

@@ -7,8 +7,8 @@
 
 START_TEST(Session_init_ShallWork)
 {
-	UA_Session session;
-	UA_Session_init(&session);
+    UA_Session session;
+    UA_Session_init(&session);
 
     UA_NodeId tmpNodeId;
     UA_NodeId_init(&tmpNodeId);
@@ -16,9 +16,9 @@ START_TEST(Session_init_ShallWork)
     UA_ApplicationDescription_init(&tmpAppDescription);
     UA_DateTime tmpDateTime;
     UA_DateTime_init(&tmpDateTime);
-	ck_assert_int_eq(session.activated,false);
-	ck_assert_int_eq(session.authenticationToken.identifier.numeric,tmpNodeId.identifier.numeric);
-	ck_assert_int_eq(session.availableContinuationPoints,MAXCONTINUATIONPOINTS);
+    ck_assert_int_eq(session.activated,false);
+    ck_assert_int_eq(session.authenticationToken.identifier.numeric,tmpNodeId.identifier.numeric);
+    ck_assert_int_eq(session.availableContinuationPoints,MAXCONTINUATIONPOINTS);
     ck_assert_ptr_eq(session.channel,NULL);
     ck_assert_ptr_eq(session.clientDescription.applicationName.locale.data,NULL);
     ck_assert_ptr_eq(session.continuationPoints.lh_first, NULL);
@@ -33,40 +33,40 @@ END_TEST
 
 START_TEST(Session_updateLifetime_ShallWork)
 {
-	UA_Session session;
-	UA_Session_init(&session);
+    UA_Session session;
+    UA_Session_init(&session);
     UA_DateTime tmpDateTime;
     tmpDateTime = session.validTill;
-	UA_Session_updateLifetime(&session);
+    UA_Session_updateLifetime(&session);
 
-	UA_Int32 result = (session.validTill > tmpDateTime);
-	ck_assert_int_gt(result,0);
+    UA_Int32 result = (session.validTill > tmpDateTime);
+    ck_assert_int_gt(result,0);
 }
 END_TEST
 
 static Suite* testSuite_Session(void) {
-	Suite *s = suite_create("Session");
-	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, Session_init_ShallWork);
-	tcase_add_test(tc_core, Session_updateLifetime_ShallWork);
+    Suite *s = suite_create("Session");
+    TCase *tc_core = tcase_create("Core");
+    tcase_add_test(tc_core, Session_init_ShallWork);
+    tcase_add_test(tc_core, Session_updateLifetime_ShallWork);
 
-	suite_add_tcase(s,tc_core);
-	return s;
+    suite_add_tcase(s,tc_core);
+    return s;
 }
 
 int main(void) {
-	int number_failed = 0;
+    int number_failed = 0;
 
-	Suite *s;
-	SRunner *sr;
+    Suite *s;
+    SRunner *sr;
 
-	s = testSuite_Session();
-	sr = srunner_create(s);
-	srunner_run_all(sr,CK_NORMAL);
-	number_failed += srunner_ntests_failed(sr);
-	srunner_free(sr);
+    s = testSuite_Session();
+    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;
+    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }