fiexd tests

Makefile

@@ -70,6 +70,16 @@ rebuild_cache:
 rebuild_cache/fast: rebuild_cache
 .PHONY : rebuild_cache/fast
 
+# Special rule for the target test
+test:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running tests..."
+	/usr/bin/ctest --force-new-ctest-process $(ARGS)
+.PHONY : test
+
+# Special rule for the target test
+test/fast: test
+.PHONY : test/fast
+
 # The main all target
 all: cmake_check_build_system
 	$(CMAKE_COMMAND) -E cmake_progress_start /home/opcua/Downloads/open62541_external_datasource/CMakeFiles /home/opcua/Downloads/open62541_external_datasource/CMakeFiles/progress.marks
@@ -140,6 +150,58 @@ open62541-objects/fast:
 	$(MAKE) -f CMakeFiles/open62541-objects.dir/build.make CMakeFiles/open62541-objects.dir/build
 .PHONY : open62541-objects/fast
 
+#=============================================================================
+# Target rules for targets named check_builtin
+
+# Build rule for target.
+check_builtin: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 check_builtin
+.PHONY : check_builtin
+
+# fast build rule for target.
+check_builtin/fast:
+	$(MAKE) -f tests/CMakeFiles/check_builtin.dir/build.make tests/CMakeFiles/check_builtin.dir/build
+.PHONY : check_builtin/fast
+
+#=============================================================================
+# Target rules for targets named check_memory
+
+# Build rule for target.
+check_memory: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 check_memory
+.PHONY : check_memory
+
+# fast build rule for target.
+check_memory/fast:
+	$(MAKE) -f tests/CMakeFiles/check_memory.dir/build.make tests/CMakeFiles/check_memory.dir/build
+.PHONY : check_memory/fast
+
+#=============================================================================
+# Target rules for targets named check_nodestore
+
+# Build rule for target.
+check_nodestore: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 check_nodestore
+.PHONY : check_nodestore
+
+# fast build rule for target.
+check_nodestore/fast:
+	$(MAKE) -f tests/CMakeFiles/check_nodestore.dir/build.make tests/CMakeFiles/check_nodestore.dir/build
+.PHONY : check_nodestore/fast
+
+#=============================================================================
+# Target rules for targets named check_services_view
+
+# Build rule for target.
+check_services_view: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 check_services_view
+.PHONY : check_services_view
+
+# fast build rule for target.
+check_services_view/fast:
+	$(MAKE) -f tests/CMakeFiles/check_services_view.dir/build.make tests/CMakeFiles/check_services_view.dir/build
+.PHONY : check_services_view/fast
+
 examples/logger_stdout.o: examples/logger_stdout.c.o
 .PHONY : examples/logger_stdout.o
 
@@ -847,6 +909,11 @@ help:
 	@echo "... open62541"
 	@echo "... open62541-objects"
 	@echo "... rebuild_cache"
+	@echo "... test"
+	@echo "... check_builtin"
+	@echo "... check_memory"
+	@echo "... check_nodestore"
+	@echo "... check_services_view"
 	@echo "... examples/logger_stdout.o"
 	@echo "... examples/logger_stdout.i"
 	@echo "... examples/logger_stdout.s"

examples/ua_nodestore_concurrent.c

@@ -1,4 +1,4 @@
-#include "ua_nodestore.h"
+#include "open62541NodeStore.h"
 #include "ua_util.h"
 
 #include <urcu.h>
@@ -8,14 +8,14 @@
 
 #define ALIVE_BIT (1 << 15) /* Alive bit in the readcount */
 
-typedef struct UA_NodeStore_Entry {
+typedef struct open62541NodeStore_Entry {
     struct cds_lfht_node htn;      /* contains next-ptr for urcu-hashmap */
     struct rcu_head      rcu_head; /* For call-rcu */
     UA_UInt16 readcount;           /* Counts the amount of readers on it [alive-bit, 15 counter-bits] */
     UA_Node   node;                /* Might be cast from any _bigger_ UA_Node* type. Allocate enough memory! */
-} UA_NodeStore_Entry;
+} open62541NodeStore_Entry;
 
-struct UA_NodeStore {
+struct open62541NodeStore {
     struct cds_lfht *ht; /* Hash table */
 };
 
@@ -98,7 +98,7 @@ static INLINE hash_t hash(const UA_NodeId *n) {
 }
 
 /****************/
-/* UA_NodeStore */
+/* open62541NodeStore */
 /****************/
 
 static inline void node_deleteMembers(const UA_Node *node) {
@@ -144,7 +144,7 @@ static inline void node_deleteMembers(const UA_Node *node) {
 /* We are in a rcu_read lock. So the node will not be freed under our feet. */
 static int compare(struct cds_lfht_node *htn, const void *orig) {
     UA_NodeId *origid = (UA_NodeId *)orig;
-    UA_NodeId *newid  = &((UA_NodeStore_Entry *)htn)->node.nodeId;   /* The htn is first in the entry structure. */
+    UA_NodeId *newid  = &((open62541NodeStore_Entry *)htn)->node.nodeId;   /* The htn is first in the entry structure. */
 
     return UA_NodeId_equal(newid, origid);
 }
@@ -154,7 +154,7 @@ static int compare(struct cds_lfht_node *htn, const void *orig) {
    section) increased the readcount, we only need to wait for the readcount
    to reach zero. */
 static void markDead(struct rcu_head *head) {
-    UA_NodeStore_Entry *entry = caa_container_of(head, UA_NodeStore_Entry, rcu_head);
+    open62541NodeStore_Entry *entry = caa_container_of(head, open62541NodeStore_Entry, rcu_head);
     if(uatomic_sub_return(&entry->readcount, ALIVE_BIT) > 0)
         return;
 
@@ -164,8 +164,8 @@ static void markDead(struct rcu_head *head) {
 }
 
 /* Free the entry if it is dead and nobody uses it anymore */
-void UA_NodeStore_release(const UA_Node *managed) {
-    UA_NodeStore_Entry *entry = caa_container_of(managed, UA_NodeStore_Entry, node); // pointer to the first entry
+void open62541NodeStore_release(const UA_Node *managed) {
+    open62541NodeStore_Entry *entry = caa_container_of(managed, open62541NodeStore_Entry, node); // pointer to the first entry
     if(uatomic_sub_return(&entry->readcount, 1) > 0)
         return;
 
@@ -174,9 +174,9 @@ void UA_NodeStore_release(const UA_Node *managed) {
     return;
 }
 
-UA_StatusCode UA_NodeStore_new(UA_NodeStore **result) {
-    UA_NodeStore *ns;
-    if(!(ns = UA_alloc(sizeof(UA_NodeStore))))
+UA_StatusCode open62541NodeStore_new(open62541NodeStore **result) {
+    open62541NodeStore *ns;
+    if(!(ns = UA_alloc(sizeof(open62541NodeStore))))
         return UA_STATUSCODE_BADOUTOFMEMORY;
 
     /* 32 is the minimum size for the hashtable. */
@@ -190,7 +190,7 @@ UA_StatusCode UA_NodeStore_new(UA_NodeStore **result) {
     return UA_STATUSCODE_GOOD;
 }
 
-void UA_NodeStore_delete(UA_NodeStore *ns) {
+void open62541NodeStore_delete(open62541NodeStore *ns) {
     struct cds_lfht      *ht = ns->ht;
     struct cds_lfht_iter  iter;
     struct cds_lfht_node *found_htn;
@@ -200,7 +200,7 @@ void UA_NodeStore_delete(UA_NodeStore *ns) {
     while(iter.node != UA_NULL) {
         found_htn = cds_lfht_iter_get_node(&iter);
         if(!cds_lfht_del(ht, found_htn)) {
-            UA_NodeStore_Entry *entry = caa_container_of(found_htn, UA_NodeStore_Entry, htn);
+            open62541NodeStore_Entry *entry = caa_container_of(found_htn, open62541NodeStore_Entry, htn);
             call_rcu(&entry->rcu_head, markDead);
         }
         cds_lfht_next(ht, &iter);
@@ -211,7 +211,7 @@ void UA_NodeStore_delete(UA_NodeStore *ns) {
     UA_free(ns);
 }
 
-UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flags) {
+UA_StatusCode open62541NodeStore_insert(open62541NodeStore *ns, UA_Node **node, UA_Byte flags) {
     UA_UInt32 nodesize;
     /* Copy the node into the entry. Then reset the original node. It shall no longer be used. */
     switch((*node)->nodeClass) {
@@ -251,19 +251,19 @@ UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flag
         return UA_STATUSCODE_BADINTERNALERROR;
     }
 
-    UA_NodeStore_Entry *entry;
-    if(!(entry = UA_alloc(sizeof(UA_NodeStore_Entry) - sizeof(UA_Node) + nodesize)))
+    open62541NodeStore_Entry *entry;
+    if(!(entry = UA_alloc(sizeof(open62541NodeStore_Entry) - sizeof(UA_Node) + nodesize)))
         return UA_STATUSCODE_BADOUTOFMEMORY;
     memcpy(&entry->node, *node, nodesize);
 
     cds_lfht_node_init(&entry->htn);
     entry->readcount = ALIVE_BIT;
-    if(flags & UA_NODESTORE_INSERT_GETMANAGED)
+    if(flags & open62541NodeStore_INSERT_GETMANAGED)
         entry->readcount++;
 
     hash_t nhash = hash(&(*node)->nodeId);
     struct cds_lfht_node *result;
-    if(flags & UA_NODESTORE_INSERT_UNIQUE) {
+    if(flags & open62541NodeStore_INSERT_UNIQUE) {
         rcu_read_lock();
         result = cds_lfht_add_unique(ns->ht, nhash, compare, &entry->node.nodeId, &entry->htn);
         rcu_read_unlock();
@@ -278,14 +278,14 @@ UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flag
         result = cds_lfht_add_replace(ns->ht, nhash, compare, &(*node)->nodeId, &entry->htn);
         /* If an entry got replaced, mark it as dead. */
         if(result) {
-            UA_NodeStore_Entry *entry = caa_container_of(result, UA_NodeStore_Entry, htn);
+            open62541NodeStore_Entry *entry = caa_container_of(result, open62541NodeStore_Entry, htn);
             call_rcu(&entry->rcu_head, markDead);      /* Queue this for the next time when no readers are on the entry.*/
         }
         rcu_read_unlock();
     }
 
     UA_free((UA_Node *)*node);     /* The old node is replaced by a managed node. */
-    if(flags & UA_NODESTORE_INSERT_GETMANAGED)
+    if(flags & open62541NodeStore_INSERT_GETMANAGED)
         *node = &entry->node;
     else
         *node = UA_NULL;
@@ -293,7 +293,7 @@ UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node **node, UA_Byte flag
     return UA_STATUSCODE_GOOD;
 }
 
-UA_StatusCode UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
+UA_StatusCode open62541NodeStore_remove(open62541NodeStore *ns, const UA_NodeId *nodeid) {
     hash_t nhash = hash(nodeid);
     struct cds_lfht_iter iter;
 
@@ -307,20 +307,20 @@ UA_StatusCode UA_NodeStore_remove(UA_NodeStore *ns, const UA_NodeId *nodeid) {
         return UA_STATUSCODE_BADNODEIDUNKNOWN;
     }
 
-    UA_NodeStore_Entry *entry = caa_container_of(found_htn, UA_NodeStore_Entry, htn);
+    open62541NodeStore_Entry *entry = caa_container_of(found_htn, open62541NodeStore_Entry, htn);
     call_rcu(&entry->rcu_head, markDead);
     rcu_read_unlock();
 
     return UA_STATUSCODE_GOOD;
 }
 
-UA_StatusCode UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
+UA_StatusCode open62541NodeStore_get(const open62541NodeStore *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
     hash_t nhash = hash(nodeid);
     struct cds_lfht_iter iter;
 
     rcu_read_lock();
     cds_lfht_lookup(ns->ht, nhash, compare, nodeid, &iter);
-    UA_NodeStore_Entry *found_entry = (UA_NodeStore_Entry *)cds_lfht_iter_get_node(&iter);
+    open62541NodeStore_Entry *found_entry = (open62541NodeStore_Entry *)cds_lfht_iter_get_node(&iter);
 
     if(!found_entry) {
         rcu_read_unlock();
@@ -335,19 +335,19 @@ UA_StatusCode UA_NodeStore_get(const UA_NodeStore *ns, const UA_NodeId *nodeid,
     return UA_STATUSCODE_GOOD;
 }
 
-void UA_NodeStore_iterate(const UA_NodeStore *ns, UA_NodeStore_nodeVisitor visitor) {
+void open62541NodeStore_iterate(const open62541NodeStore *ns, open62541NodeStore_nodeVisitor visitor) {
     struct cds_lfht     *ht = ns->ht;
     struct cds_lfht_iter iter;
 
     rcu_read_lock();
     cds_lfht_first(ht, &iter);
     while(iter.node != UA_NULL) {
-        UA_NodeStore_Entry *found_entry = (UA_NodeStore_Entry *)cds_lfht_iter_get_node(&iter);
+        open62541NodeStore_Entry *found_entry = (open62541NodeStore_Entry *)cds_lfht_iter_get_node(&iter);
         uatomic_inc(&found_entry->readcount);
         const UA_Node      *node = &found_entry->node;
         rcu_read_unlock();
         visitor(node);
-        UA_NodeStore_release((UA_Node *)node);
+        open62541NodeStore_release((UA_Node *)node);
         rcu_read_lock();
         cds_lfht_next(ht, &iter);
     }

src/server/nodestore/open62541_nodestore.h

@@ -53,7 +53,7 @@ UA_StatusCode open62541NodeStore_get(const open62541NodeStore *ns,
 
 /** @brief Release a managed node. Do never insert a node that isn't stored in a
  namespace. */
-void open62541NodeStore_releaseManagedNode(const UA_Node *managed);
+void open62541NodeStore_release(const UA_Node *managed);
 
 /** @brief A function that can be evaluated on all entries in a namespace via
  UA_NodeStore_iterate. Note that the visitor is read-only on the nodes. */

src/server/nodestore/open62541_nodestore_attribute.c

@@ -203,7 +203,7 @@ static UA_DataValue service_read_node(UA_Server *server,
 		break;
 	}
 
-	open62541NodeStore_releaseManagedNode(node);
+	open62541NodeStore_release(node);
 
 	if (retval != UA_STATUSCODE_GOOD) {
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
@@ -353,7 +353,7 @@ static UA_StatusCode Service_Write_writeNode(open62541NodeStore *nodestore,
 		break;
 	}
 
-	open62541NodeStore_releaseManagedNode(node);
+	open62541NodeStore_release(node);
 	return retval;
 
 }

src/server/nodestore/open62541_nodestore_core.c

@@ -361,6 +361,6 @@ void open62541NodeStore_iterate(const open62541NodeStore *ns,
 	}
 }
 
-void open62541NodeStore_releaseManagedNode(const UA_Node *managed) {
+void open62541NodeStore_release(const UA_Node *managed) {
 	;
 }

src/server/nodestore/open62541_nodestore_nodemanagement.c

@@ -55,7 +55,7 @@ static UA_Int32 AddReference(open62541NodeStore *nodestore, UA_Node *node,
 	inversereference.targetId.namespaceUri = UA_STRING_NULL;
 	inversereference.targetId.serverIndex = 0;
 	retval = AddSingleReference(targetnode, &inversereference);
-	open62541NodeStore_releaseManagedNode(targetnode);
+	open62541NodeStore_release(targetnode);
 
 	return retval;
 }

src/server/nodestore/open62541_nodestore_view.c

@@ -48,7 +48,7 @@ static UA_StatusCode fillReferenceDescription(open62541NodeStore *ns, const UA_N
     }
 
     if(currentNode)
-    	open62541NodeStore_releaseManagedNode(currentNode);
+    	open62541NodeStore_release(currentNode);
     if(retval)
         UA_ReferenceDescription_deleteMembers(referenceDescription);
     return retval;
@@ -86,7 +86,7 @@ static UA_Boolean isRelevantTargetNode(open62541NodeStore *ns, const UA_BrowseDe
         return UA_FALSE;
 
     if(((*currentNode)->nodeClass & browseDescription->nodeClassMask) == 0) {
-    	open62541NodeStore_releaseManagedNode(*currentNode);
+    	open62541NodeStore_release(*currentNode);
         return UA_FALSE;
     }
 
@@ -146,7 +146,7 @@ static UA_StatusCode findRelevantReferenceTypes(open62541NodeStore *ns, const UA
             if(retval)
                 currentLastIndex--; // undo if we need to delete the typeArray
         }
-        open62541NodeStore_releaseManagedNode((UA_Node*)node);
+        open62541NodeStore_release((UA_Node*)node);
     } while(++currentIndex <= currentLastIndex && retval == UA_STATUSCODE_GOOD);
 
     if(retval)
@@ -220,7 +220,7 @@ static void getBrowseResult(open62541NodeStore *ns, const UA_BrowseDescription *
         browseResult->referencesSize = currentRefs;
     }
 
-    open62541NodeStore_releaseManagedNode(parentNode);
+    open62541NodeStore_release(parentNode);
     if(!returnAll && browseDescription->includeSubtypes)
         UA_Array_delete(relevantReferenceTypes, relevantReferenceTypesSize, &UA_TYPES[UA_NODEID]);
 }

tests/check_nodestore.c

@@ -3,7 +3,7 @@
 #include <time.h>
 
 #include "ua_types.h"
-#include "server/ua_nodestore.h"
+#include "server/nodestore/open62541_nodestore.h"
 #include "ua_util.h"
 #include "check.h"
 
@@ -23,10 +23,10 @@ void printVisitor(const UA_Node* node) {
 	printf("%d\n", node->nodeId.identifier.numeric);
 }
 
-START_TEST(test_UA_NodeStore) {
-	UA_NodeStore *ns = UA_NULL;
-	UA_NodeStore_new(&ns);
-	UA_NodeStore_delete(ns);
+START_TEST(test_open62541NodeStore) {
+	open62541NodeStore *ns = UA_NULL;
+	open62541NodeStore_new(&ns);
+	open62541NodeStore_delete(ns);
 }
 END_TEST
 
@@ -39,113 +39,113 @@ UA_StatusCode createNode(UA_Node** p, UA_Int16 nsid, UA_Int32 id) {
 	return UA_STATUSCODE_GOOD;
 }
 
-START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
+START_TEST(findNodeInopen62541NodeStoreWithSingleEntry) {
 #ifdef MULTITHREADING
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
 	UA_Node* n1; createNode(&n1,0,2253);
-	UA_NodeStore_insert(ns, &n1, UA_NODESTORE_INSERT_UNIQUE | UA_NODESTORE_INSERT_GETMANAGED);
+	open62541NodeStore_insert(ns, &n1, UA_NODESTORE_INSERT_UNIQUE | UA_NODESTORE_INSERT_GETMANAGED);
 	const UA_Node* nr = UA_NULL;
 	UA_Int32 retval;
 	// when
-	retval = UA_NodeStore_get(ns,&n1->nodeId,&nr);
+	retval = open62541NodeStore_get(ns,&n1->nodeId,&nr);
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_ptr_eq((void*)nr, (void*)n1);
 	// finally
-	UA_NodeStore_release(n1);
-	UA_NodeStore_release(nr);
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_release(n1);
+	open62541NodeStore_release(nr);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
 }
 END_TEST
 
-START_TEST(failToFindNodeInOtherUA_NodeStore) {
+START_TEST(failToFindNodeInOtheropen62541NodeStore) {
 #ifdef MULTITHREADING
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns = UA_NULL;
-	UA_NodeStore_new(&ns);
+	open62541NodeStore *ns = UA_NULL;
+	open62541NodeStore_new(&ns);
 
-	UA_Node* n1; createNode(&n1,0,2253); UA_NodeStore_insert(ns, &n1, 0);
-	UA_Node* n2; createNode(&n2,0,2253); UA_NodeStore_insert(ns, &n2, 0);
+	UA_Node* n1; createNode(&n1,0,2253); open62541NodeStore_insert(ns, &n1, 0);
+	UA_Node* n2; createNode(&n2,0,2253); open62541NodeStore_insert(ns, &n2, 0);
 
 	const UA_Node* nr = UA_NULL;
 	// when
 	UA_Node* n; createNode(&n,1,2255);
-	UA_Int32 retval = UA_NodeStore_get(ns,&n->nodeId, &nr);
+	UA_Int32 retval = open62541NodeStore_get(ns,&n->nodeId, &nr);
 	// then
 	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_Node_delete(n);
-	UA_NodeStore_release(nr);
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_release(nr);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
 }
 END_TEST
 
-START_TEST(findNodeInUA_NodeStoreWithSeveralEntries) {
+START_TEST(findNodeInopen62541NodeStoreWithSeveralEntries) {
 #ifdef MULTITHREADING
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
-	UA_Node* n1; createNode(&n1,0,2253); UA_NodeStore_insert(ns, &n1, 0);
-	UA_Node* n2; createNode(&n2,0,2255); UA_NodeStore_insert(ns, &n2, 0);
-	UA_Node* n3; createNode(&n3,0,2257); UA_NodeStore_insert(ns, &n3, UA_NODESTORE_INSERT_GETMANAGED);
-	UA_Node* n4; createNode(&n4,0,2200); UA_NodeStore_insert(ns, &n4, 0);
-	UA_Node* n5; createNode(&n5,0,1); UA_NodeStore_insert(ns, &n5, 0);
-	UA_Node* n6; createNode(&n6,0,12); UA_NodeStore_insert(ns, &n6, 0);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
+	UA_Node* n1; createNode(&n1,0,2253); open62541NodeStore_insert(ns, &n1, 0);
+	UA_Node* n2; createNode(&n2,0,2255); open62541NodeStore_insert(ns, &n2, 0);
+	UA_Node* n3; createNode(&n3,0,2257); open62541NodeStore_insert(ns, &n3, UA_NODESTORE_INSERT_GETMANAGED);
+	UA_Node* n4; createNode(&n4,0,2200); open62541NodeStore_insert(ns, &n4, 0);
+	UA_Node* n5; createNode(&n5,0,1); open62541NodeStore_insert(ns, &n5, 0);
+	UA_Node* n6; createNode(&n6,0,12); open62541NodeStore_insert(ns, &n6, 0);
 
 	const UA_Node* nr = UA_NULL;
 	UA_Int32 retval;
 	// when
-	retval = UA_NodeStore_get(ns,&(n3->nodeId),&nr);
+	retval = open62541NodeStore_get(ns,&(n3->nodeId),&nr);
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_ptr_eq((void*)nr, (void*)n3);
 	// finally
-	UA_NodeStore_release(n3);
-	UA_NodeStore_release(nr);
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_release(n3);
+	open62541NodeStore_release(nr);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
 }
 END_TEST
 
-START_TEST(iterateOverUA_NodeStoreShallNotVisitEmptyNodes) {
+START_TEST(iterateOveropen62541NodeStoreShallNotVisitEmptyNodes) {
 #ifdef MULTITHREADING
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
-	UA_Node* n1; createNode(&n1,0,2253); UA_NodeStore_insert(ns, &n1, 0);
-	UA_Node* n2; createNode(&n2,0,2255); UA_NodeStore_insert(ns, &n2, 0);
-	UA_Node* n3; createNode(&n3,0,2257); UA_NodeStore_insert(ns, &n3, 0);
-	UA_Node* n4; createNode(&n4,0,2200); UA_NodeStore_insert(ns, &n4, 0);
-	UA_Node* n5; createNode(&n5,0,1); UA_NodeStore_insert(ns, &n5, 0);
-	UA_Node* n6; createNode(&n6,0,12); UA_NodeStore_insert(ns, &n6, 0);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
+	UA_Node* n1; createNode(&n1,0,2253); open62541NodeStore_insert(ns, &n1, 0);
+	UA_Node* n2; createNode(&n2,0,2255); open62541NodeStore_insert(ns, &n2, 0);
+	UA_Node* n3; createNode(&n3,0,2257); open62541NodeStore_insert(ns, &n3, 0);
+	UA_Node* n4; createNode(&n4,0,2200); open62541NodeStore_insert(ns, &n4, 0);
+	UA_Node* n5; createNode(&n5,0,1); open62541NodeStore_insert(ns, &n5, 0);
+	UA_Node* n6; createNode(&n6,0,12); open62541NodeStore_insert(ns, &n6, 0);
 
 	// when
 	zeroCnt = 0;
 	visitCnt = 0;
-	UA_NodeStore_iterate(ns,checkZeroVisitor);
+	open62541NodeStore_iterate(ns,checkZeroVisitor);
 	// then
 	ck_assert_int_eq(zeroCnt, 0);
 	ck_assert_int_eq(visitCnt, 6);
 	// finally
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
@@ -157,25 +157,25 @@ START_TEST(findNodeInExpandedNamespace) {
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
 	UA_Node* n;
 	UA_Int32 i=0;
 	for (; i<200; i++) {
-		createNode(&n,0,i); UA_NodeStore_insert(ns, &n, 0);
+		createNode(&n,0,i); open62541NodeStore_insert(ns, &n, 0);
 	}
 	const UA_Node* nr = UA_NULL;
 	UA_Int32 retval;
 	// when
 	createNode(&n,0,25);
-	retval = UA_NodeStore_get(ns,&(n->nodeId),&nr);
+	retval = open62541NodeStore_get(ns,&(n->nodeId),&nr);
 	// then
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	ck_assert_int_eq(nr->nodeId.identifier.numeric,n->nodeId.identifier.numeric);
 	// finally
 	UA_free((void*)n);
-	UA_NodeStore_release(nr);
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_release(nr);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
@@ -187,51 +187,51 @@ START_TEST(iterateOverExpandedNamespaceShallNotVisitEmptyNodes) {
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
 	UA_Node* n;
 	UA_Int32 i=0;
 	for (; i<200; i++) {
-		createNode(&n,0,i); UA_NodeStore_insert(ns, &n, 0);
+		createNode(&n,0,i); open62541NodeStore_insert(ns, &n, 0);
 	}
 	// when
 	zeroCnt = 0;
 	visitCnt = 0;
-	UA_NodeStore_iterate(ns,checkZeroVisitor);
+	open62541NodeStore_iterate(ns,checkZeroVisitor);
 	// then
 	ck_assert_int_eq(zeroCnt, 0);
 	ck_assert_int_eq(visitCnt, 200);
 	// finally
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
 }
 END_TEST
 
-START_TEST(failToFindNonExistantNodeInUA_NodeStoreWithSeveralEntries) {
+START_TEST(failToFindNonExistantNodeInopen62541NodeStoreWithSeveralEntries) {
 #ifdef MULTITHREADING
    	rcu_register_thread();
 #endif
 	// given
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
-	UA_Node* n1; createNode(&n1,0,2253); UA_NodeStore_insert(ns, &n1, 0);
-	UA_Node* n2; createNode(&n2,0,2255); UA_NodeStore_insert(ns, &n2, 0);
-	UA_Node* n3; createNode(&n3,0,2257); UA_NodeStore_insert(ns, &n3, 0);
-	UA_Node* n4; createNode(&n4,0,2200); UA_NodeStore_insert(ns, &n4, 0);
-	UA_Node* n5; createNode(&n5,0,1); UA_NodeStore_insert(ns, &n5, 0);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
+	UA_Node* n1; createNode(&n1,0,2253); open62541NodeStore_insert(ns, &n1, 0);
+	UA_Node* n2; createNode(&n2,0,2255); open62541NodeStore_insert(ns, &n2, 0);
+	UA_Node* n3; createNode(&n3,0,2257); open62541NodeStore_insert(ns, &n3, 0);
+	UA_Node* n4; createNode(&n4,0,2200); open62541NodeStore_insert(ns, &n4, 0);
+	UA_Node* n5; createNode(&n5,0,1); open62541NodeStore_insert(ns, &n5, 0);
 	UA_Node* n6; createNode(&n6,0,12); 
 
 	const UA_Node* nr = UA_NULL;
 	UA_Int32 retval;
 	// when
-	retval = UA_NodeStore_get(ns, &(n6->nodeId), &nr);
+	retval = open62541NodeStore_get(ns, &(n6->nodeId), &nr);
 	// then
 	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 	// finally
 	UA_free((void *)n6);
-	UA_NodeStore_delete(ns);
+	open62541NodeStore_delete(ns);
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
 #endif
@@ -243,8 +243,8 @@ END_TEST
 /************************************/
 
 #ifdef MULTITHREADING
-struct UA_NodeStoreProfileTest {
-	UA_NodeStore *ns;
+struct open62541NodeStoreProfileTest {
+	open62541NodeStore *ns;
 	UA_Int32 min_val;
 	UA_Int32 max_val;
 	UA_Int32 rounds;
@@ -252,16 +252,16 @@ struct UA_NodeStoreProfileTest {
 
 void *profileGetThread(void *arg) {
    	rcu_register_thread();
-	struct UA_NodeStoreProfileTest *test = (struct UA_NodeStoreProfileTest*) arg;
+	struct open62541NodeStoreProfileTest *test = (struct open62541NodeStoreProfileTest*) arg;
 	UA_NodeId id = NS0NODEID(0);
 	const UA_Node *cn;
 	UA_Int32 max_val = test->max_val;
-	UA_NodeStore *ns = test->ns;
+	open62541NodeStore *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, &cn);
-			UA_NodeStore_release(cn);
+			open62541NodeStore_get(ns,&id, &cn);
+			open62541NodeStore_release(cn);
 		}
 	}
 	rcu_unregister_thread();
@@ -276,21 +276,21 @@ START_TEST(profileGetDelete) {
 #endif
 
 #define N 1000000
-	UA_NodeStore *ns;
-	UA_NodeStore_new(&ns);
+	open62541NodeStore *ns;
+	open62541NodeStore_new(&ns);
 	UA_Int32 i=0;
 	UA_Node *n;
 	for (; i<N; i++) {
-		createNode(&n,0,i); UA_NodeStore_insert(ns, &n, 0);
+		createNode(&n,0,i); open62541NodeStore_insert(ns, &n, 0);
 	}
 	clock_t begin, end;
 	begin = clock();
 #ifdef MULTITHREADING
 #define THREADS 4
     pthread_t t[THREADS];
-	struct UA_NodeStoreProfileTest p[THREADS];
+	struct open62541NodeStoreProfileTest p[THREADS];
 	for (int i = 0; i < THREADS; i++) {
-		p[i] = (struct UA_NodeStoreProfileTest){ns, i*(N/THREADS), (i+1)*(N/THREADS), 50};
+		p[i] = (struct open62541NodeStoreProfileTest){ns, i*(N/THREADS), (i+1)*(N/THREADS), 50};
 		pthread_create(&t[i], NULL, profileGetThread, &p[i]);
 	}
 	for (int i = 0; i < THREADS; i++)
@@ -303,15 +303,15 @@ START_TEST(profileGetDelete) {
 	for(UA_Int32 x = 0; x<50; x++) {
 	    for(i=0; i<N; i++) {
 	        id.identifier.numeric = i;
-			UA_NodeStore_get(ns,&id, &cn);
-			UA_NodeStore_release(cn);
+			open62541NodeStore_get(ns,&id, &cn);
+			open62541NodeStore_release(cn);
         }
     }
 	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);
+	open62541NodeStore_delete(ns);
 
 #ifdef MULTITHREADING
 	rcu_unregister_thread();
@@ -320,22 +320,22 @@ START_TEST(profileGetDelete) {
 END_TEST
 
 Suite * namespace_suite (void) {
-	Suite *s = suite_create ("UA_NodeStore");
+	Suite *s = suite_create ("open62541NodeStore");
 
 	TCase *tc_cd = tcase_create ("Create/Delete");
-	tcase_add_test (tc_cd, test_UA_NodeStore);
+	tcase_add_test (tc_cd, test_open62541NodeStore);
 	suite_add_tcase (s, tc_cd);
 
 	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, findNodeInopen62541NodeStoreWithSingleEntry);
+	tcase_add_test (tc_find, findNodeInopen62541NodeStoreWithSeveralEntries);
 	tcase_add_test (tc_find, findNodeInExpandedNamespace);
-	tcase_add_test (tc_find, failToFindNonExistantNodeInUA_NodeStoreWithSeveralEntries);
-	tcase_add_test (tc_find, failToFindNodeInOtherUA_NodeStore);
+	tcase_add_test (tc_find, failToFindNonExistantNodeInopen62541NodeStoreWithSeveralEntries);
+	tcase_add_test (tc_find, failToFindNodeInOtheropen62541NodeStore);
 	suite_add_tcase (s, tc_find);
 
 	TCase* tc_iterate = tcase_create ("Iterate");
-	tcase_add_test (tc_iterate, iterateOverUA_NodeStoreShallNotVisitEmptyNodes);
+	tcase_add_test (tc_iterate, iterateOveropen62541NodeStoreShallNotVisitEmptyNodes);
 	tcase_add_test (tc_iterate, iterateOverExpandedNamespaceShallNotVisitEmptyNodes);
 	suite_add_tcase (s, tc_iterate);