ext/open62541/tests/server/check_nodestore.c - a71ch-crypto-support - Git at Google

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include <open62541/types.h>
 #include <open62541/util.h>
 #include <open62541/plugin/nodestore.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>

 #include "check.h"
 #include "ziptree.h"

 /* container_of */
 #define container_of(ptr, type, member) \
     (type *)((uintptr_t)ptr - offsetof(type,member))

 #if UA_MULTITHREADING >= 200
 #include <pthread.h>
 #endif

 /* Dirty redifinition from ua_nodestore_default.c to check that all nodes were
  * released */
 struct NodeEntry;
 typedef struct NodeEntry NodeEntry;

 struct NodeEntry {
     ZIP_ENTRY(NodeEntry) zipfields;
     UA_UInt32 nodeIdHash;
     UA_UInt16 refCount; /* How many consumers have a reference to the node? */
     UA_Boolean deleted; /* Node was marked as deleted and can be deleted when refCount == 0 */
     NodeEntry *orig;    /* If a copy is made to replace a node, track that we
                          * replace only the node from which the copy was made.
                          * Important for concurrent operations. */
     UA_NodeId nodeId; /* This is actually a UA_Node that also starts with a NodeId */
 };

 static void checkAllReleased(void *context, const UA_Node* node) {
     NodeEntry *entry = container_of(node, NodeEntry, nodeId);
     ck_assert_int_eq(entry->refCount, 0); /* The count is increased when the visited node is checked out */
 }

 void *nsCtx;

 static void setup(void) {
     UA_Nodestore_new(&nsCtx);
 }

 static void teardown(void) {
     UA_Nodestore_iterate(nsCtx, checkAllReleased, NULL);
     UA_Nodestore_delete(nsCtx);
 }

 static int zeroCnt = 0;
 static int visitCnt = 0;
 static void checkZeroVisitor(void *context, const UA_Node* node) {
     visitCnt++;
     if (node == NULL) zeroCnt++;
 }

 static UA_Node* createNode(UA_Int16 nsid, UA_Int32 id) {
     UA_Node *p = UA_Nodestore_newNode(nsCtx, UA_NODECLASS_VARIABLE);
     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_Node* n1 = createNode(0,2253);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_NodeId in1 = UA_NODEID_NUMERIC(0, 2253);
     UA_Node* n2;
     UA_Nodestore_getNodeCopy(nsCtx, &in1, &n2);
     UA_StatusCode retval = UA_Nodestore_replaceNode(nsCtx, n2);
     ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST

 START_TEST(replaceOldNode) {
     UA_Node* n1 = createNode(0,2253);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_NodeId in1 = UA_NODEID_NUMERIC(0,2253);
     UA_Node* n2;
     UA_Node* n3;
     UA_Nodestore_getNodeCopy(nsCtx, &in1, &n2);
     UA_Nodestore_getNodeCopy(nsCtx, &in1, &n3);

     /* shall succeed */
     UA_StatusCode retval = UA_Nodestore_replaceNode(nsCtx, n2);
     ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);

     /* shall fail */
     retval = UA_Nodestore_replaceNode(nsCtx, n3);
     ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
 }
 END_TEST

 START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
     UA_Node* n1 = createNode(0,2253);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_NodeId in1 = UA_NODEID_NUMERIC(0,2253);
     const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &in1);
     ck_assert_int_eq((uintptr_t)n1, (uintptr_t)nr);
     UA_Nodestore_releaseNode(nsCtx, nr);
 }
 END_TEST

 START_TEST(failToFindNodeInOtherUA_NodeStore) {
     UA_Node* n1 = createNode(0,2255);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_NodeId in1 = UA_NODEID_NUMERIC(1, 2255);
     const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &in1);
     ck_assert_int_eq((uintptr_t)nr, 0);
 }
 END_TEST

 START_TEST(findNodeInUA_NodeStoreWithSeveralEntries) {
     UA_Node* n1 = createNode(0,2253);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_Node* n2 = createNode(0,2255);
     UA_Nodestore_insertNode(nsCtx, n2, NULL);
     UA_Node* n3 = createNode(0,2257);
     UA_Nodestore_insertNode(nsCtx, n3, NULL);
     UA_Node* n4 = createNode(0,2200);
     UA_Nodestore_insertNode(nsCtx, n4, NULL);
     UA_Node* n5 = createNode(0,1);
     UA_Nodestore_insertNode(nsCtx, n5, NULL);
     UA_Node* n6 = createNode(0,12);
     UA_Nodestore_insertNode(nsCtx, n6, NULL);

     UA_NodeId in3 = UA_NODEID_NUMERIC(0, 2257);
     const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &in3);
     ck_assert_int_eq((uintptr_t)nr, (uintptr_t)n3);
     UA_Nodestore_releaseNode(nsCtx, nr);
 }
 END_TEST

 START_TEST(iterateOverUA_NodeStoreShallNotVisitEmptyNodes) {
     UA_Node* n1 = createNode(0,2253);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_Node* n2 = createNode(0,2255);
     UA_Nodestore_insertNode(nsCtx, n2, NULL);
     UA_Node* n3 = createNode(0,2257);
     UA_Nodestore_insertNode(nsCtx, n3, NULL);
     UA_Node* n4 = createNode(0,2200);
     UA_Nodestore_insertNode(nsCtx, n4, NULL);
     UA_Node* n5 = createNode(0,1);
     UA_Nodestore_insertNode(nsCtx, n5, NULL);
     UA_Node* n6 = createNode(0,12);
     UA_Nodestore_insertNode(nsCtx, n6, NULL);

     zeroCnt = 0;
     visitCnt = 0;
     UA_Nodestore_iterate(nsCtx, checkZeroVisitor, NULL);
     ck_assert_int_eq(zeroCnt, 0);
     ck_assert_int_eq(visitCnt, 6);
 }
 END_TEST

 START_TEST(findNodeInExpandedNamespace) {
     for(UA_UInt32 i = 0; i < 200; i++) {
         UA_Node* n = createNode(0,i);
         UA_Nodestore_insertNode(nsCtx, n, NULL);
     }
     // when
     UA_Node *n2 = createNode(0,25);
     const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &n2->nodeId);
     ck_assert_int_eq(nr->nodeId.identifier.numeric, n2->nodeId.identifier.numeric);
     UA_Nodestore_releaseNode(nsCtx, nr);
     UA_Nodestore_deleteNode(nsCtx, n2);
 }
 END_TEST

 START_TEST(iterateOverExpandedNamespaceShallNotVisitEmptyNodes) {
     for(UA_UInt32 i = 0; i < 200; i++) {
         UA_Node* n = createNode(0,i+1);
         UA_Nodestore_insertNode(nsCtx, n, NULL);
     }
     // when
     zeroCnt = 0;
     visitCnt = 0;
     UA_Nodestore_iterate(nsCtx, checkZeroVisitor, NULL);
     // then
     ck_assert_int_eq(zeroCnt, 0);
     ck_assert_int_eq(visitCnt, 200);
 }
 END_TEST

 START_TEST(failToFindNonExistentNodeInUA_NodeStoreWithSeveralEntries) {
     UA_Node* n1 = createNode(0,2253);
     UA_Nodestore_insertNode(nsCtx, n1, NULL);
     UA_Node* n2 = createNode(0,2255);
     UA_Nodestore_insertNode(nsCtx, n2, NULL);
     UA_Node* n3 = createNode(0,2257);
     UA_Nodestore_insertNode(nsCtx, n3, NULL);
     UA_Node* n4 = createNode(0,2200);
     UA_Nodestore_insertNode(nsCtx, n4, NULL);
     UA_Node* n5 = createNode(0,1);
     UA_Nodestore_insertNode(nsCtx, n5, NULL);

     UA_NodeId id = UA_NODEID_NUMERIC(0, 12);
     const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &id);
     ck_assert_int_eq((uintptr_t)nr, 0);
 }
 END_TEST

 /************************************/
 /* Performance Profiling Test Cases */
 /************************************/

 #if UA_MULTITHREADING >= 200
 struct UA_NodeStoreProfileTest {
     UA_Int32 min_val;
     UA_Int32 max_val;
     UA_Int32 rounds;
 };

 static void *profileGetThread(void *arg) {
     struct UA_NodeStoreProfileTest *test = (struct UA_NodeStoreProfileTest*) arg;
     UA_NodeId id;
     UA_NodeId_init(&id);
     UA_Int32 max_val = test->max_val;
     for(UA_Int32 x = 0; x<test->rounds; x++) {
         for(UA_Int32 i=test->min_val; i<max_val; i++) {
             id.identifier.numeric = i+1;
             const UA_Node *n = UA_Nodestore_getNode(nsCtx, &id);
             UA_Nodestore_releaseNode(nsCtx, n);
         }
     }
     return NULL;
 }
 #endif

 #define N 1000 /* make bigger to test */

 START_TEST(profileGetDelete) {
     clock_t begin, end;
     begin = clock();

     for(UA_UInt32 i = 0; i < N; i++) {
         UA_Node *n = createNode(0,i+1);
         UA_Nodestore_insertNode(nsCtx, n, NULL);
     }

 #if UA_MULTITHREADING >= 200
 #define THREADS 4
     pthread_t t[THREADS];
     struct UA_NodeStoreProfileTest p[THREADS];
     for (int i = 0; i < THREADS; i++) {
         p[i] = (struct UA_NodeStoreProfileTest){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_NULL;
     for(size_t i = 0; i < N; i++) {
         id.identifier.numeric = (UA_UInt32)i+1;
         const UA_Node *node = UA_Nodestore_getNode(nsCtx, &id);
         UA_Nodestore_releaseNode(nsCtx, node);
     }
     end = clock();
     printf("Time for single-threaded %d create/get/delete in a namespace: %fs.\n", N,
            (double)(end - begin) / CLOCKS_PER_SEC);
 #endif
 }
 END_TEST

 static Suite * namespace_suite (void) {
     Suite *s = suite_create ("UA_NodeStore");

     TCase* tc_find = tcase_create ("Find");
     tcase_add_checked_fixture(tc_find, setup, teardown);
     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, failToFindNonExistentNodeInUA_NodeStoreWithSeveralEntries);
     tcase_add_test (tc_find, failToFindNodeInOtherUA_NodeStore);
     suite_add_tcase (s, tc_find);

     TCase *tc_replace = tcase_create("Replace");
     tcase_add_checked_fixture(tc_replace, setup, teardown);
     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_checked_fixture(tc_iterate, setup, teardown);
     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_checked_fixture(tc_profile, setup, teardown);
     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;
 }
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

	#include <open62541/types.h>
	#include <open62541/util.h>
	#include <open62541/plugin/nodestore.h>

	#include <stdio.h>
	#include <stdlib.h>
	#include <time.h>

	#include "check.h"
	#include "ziptree.h"

	/* container_of */
	#define container_of(ptr, type, member) \
	(type *)((uintptr_t)ptr - offsetof(type,member))

	#if UA_MULTITHREADING >= 200
	#include <pthread.h>
	#endif

	/* Dirty redifinition from ua_nodestore_default.c to check that all nodes were
	* released */
	struct NodeEntry;
	typedef struct NodeEntry NodeEntry;

	struct NodeEntry {
	ZIP_ENTRY(NodeEntry) zipfields;
	UA_UInt32 nodeIdHash;
	UA_UInt16 refCount; /* How many consumers have a reference to the node? */
	UA_Boolean deleted; /* Node was marked as deleted and can be deleted when refCount == 0 */
	NodeEntry orig; / If a copy is made to replace a node, track that we
	* replace only the node from which the copy was made.
	* Important for concurrent operations. */
	UA_NodeId nodeId; /* This is actually a UA_Node that also starts with a NodeId */
	};

	static void checkAllReleased(void context, const UA_Node node) {
	NodeEntry *entry = container_of(node, NodeEntry, nodeId);
	ck_assert_int_eq(entry->refCount, 0); /* The count is increased when the visited node is checked out */
	}

	void *nsCtx;

	static void setup(void) {
	UA_Nodestore_new(&nsCtx);
	}

	static void teardown(void) {
	UA_Nodestore_iterate(nsCtx, checkAllReleased, NULL);
	UA_Nodestore_delete(nsCtx);
	}

	static int zeroCnt = 0;
	static int visitCnt = 0;
	static void checkZeroVisitor(void context, const UA_Node node) {
	visitCnt++;
	if (node == NULL) zeroCnt++;
	}

	static UA_Node* createNode(UA_Int16 nsid, UA_Int32 id) {
	UA_Node *p = UA_Nodestore_newNode(nsCtx, UA_NODECLASS_VARIABLE);
	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_Node* n1 = createNode(0,2253);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_NodeId in1 = UA_NODEID_NUMERIC(0, 2253);
	UA_Node* n2;
	UA_Nodestore_getNodeCopy(nsCtx, &in1, &n2);
	UA_StatusCode retval = UA_Nodestore_replaceNode(nsCtx, n2);
	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
	}
	END_TEST

	START_TEST(replaceOldNode) {
	UA_Node* n1 = createNode(0,2253);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_NodeId in1 = UA_NODEID_NUMERIC(0,2253);
	UA_Node* n2;
	UA_Node* n3;
	UA_Nodestore_getNodeCopy(nsCtx, &in1, &n2);
	UA_Nodestore_getNodeCopy(nsCtx, &in1, &n3);

	/* shall succeed */
	UA_StatusCode retval = UA_Nodestore_replaceNode(nsCtx, n2);
	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);

	/* shall fail */
	retval = UA_Nodestore_replaceNode(nsCtx, n3);
	ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
	}
	END_TEST

	START_TEST(findNodeInUA_NodeStoreWithSingleEntry) {
	UA_Node* n1 = createNode(0,2253);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_NodeId in1 = UA_NODEID_NUMERIC(0,2253);
	const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &in1);
	ck_assert_int_eq((uintptr_t)n1, (uintptr_t)nr);
	UA_Nodestore_releaseNode(nsCtx, nr);
	}
	END_TEST

	START_TEST(failToFindNodeInOtherUA_NodeStore) {
	UA_Node* n1 = createNode(0,2255);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_NodeId in1 = UA_NODEID_NUMERIC(1, 2255);
	const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &in1);
	ck_assert_int_eq((uintptr_t)nr, 0);
	}
	END_TEST

	START_TEST(findNodeInUA_NodeStoreWithSeveralEntries) {
	UA_Node* n1 = createNode(0,2253);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_Node* n2 = createNode(0,2255);
	UA_Nodestore_insertNode(nsCtx, n2, NULL);
	UA_Node* n3 = createNode(0,2257);
	UA_Nodestore_insertNode(nsCtx, n3, NULL);
	UA_Node* n4 = createNode(0,2200);
	UA_Nodestore_insertNode(nsCtx, n4, NULL);
	UA_Node* n5 = createNode(0,1);
	UA_Nodestore_insertNode(nsCtx, n5, NULL);
	UA_Node* n6 = createNode(0,12);
	UA_Nodestore_insertNode(nsCtx, n6, NULL);

	UA_NodeId in3 = UA_NODEID_NUMERIC(0, 2257);
	const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &in3);
	ck_assert_int_eq((uintptr_t)nr, (uintptr_t)n3);
	UA_Nodestore_releaseNode(nsCtx, nr);
	}
	END_TEST

	START_TEST(iterateOverUA_NodeStoreShallNotVisitEmptyNodes) {
	UA_Node* n1 = createNode(0,2253);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_Node* n2 = createNode(0,2255);
	UA_Nodestore_insertNode(nsCtx, n2, NULL);
	UA_Node* n3 = createNode(0,2257);
	UA_Nodestore_insertNode(nsCtx, n3, NULL);
	UA_Node* n4 = createNode(0,2200);
	UA_Nodestore_insertNode(nsCtx, n4, NULL);
	UA_Node* n5 = createNode(0,1);
	UA_Nodestore_insertNode(nsCtx, n5, NULL);
	UA_Node* n6 = createNode(0,12);
	UA_Nodestore_insertNode(nsCtx, n6, NULL);

	zeroCnt = 0;
	visitCnt = 0;
	UA_Nodestore_iterate(nsCtx, checkZeroVisitor, NULL);
	ck_assert_int_eq(zeroCnt, 0);
	ck_assert_int_eq(visitCnt, 6);
	}
	END_TEST

	START_TEST(findNodeInExpandedNamespace) {
	for(UA_UInt32 i = 0; i < 200; i++) {
	UA_Node* n = createNode(0,i);
	UA_Nodestore_insertNode(nsCtx, n, NULL);
	}
	// when
	UA_Node *n2 = createNode(0,25);
	const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &n2->nodeId);
	ck_assert_int_eq(nr->nodeId.identifier.numeric, n2->nodeId.identifier.numeric);
	UA_Nodestore_releaseNode(nsCtx, nr);
	UA_Nodestore_deleteNode(nsCtx, n2);
	}
	END_TEST

	START_TEST(iterateOverExpandedNamespaceShallNotVisitEmptyNodes) {
	for(UA_UInt32 i = 0; i < 200; i++) {
	UA_Node* n = createNode(0,i+1);
	UA_Nodestore_insertNode(nsCtx, n, NULL);
	}
	// when
	zeroCnt = 0;
	visitCnt = 0;
	UA_Nodestore_iterate(nsCtx, checkZeroVisitor, NULL);
	// then
	ck_assert_int_eq(zeroCnt, 0);
	ck_assert_int_eq(visitCnt, 200);
	}
	END_TEST

	START_TEST(failToFindNonExistentNodeInUA_NodeStoreWithSeveralEntries) {
	UA_Node* n1 = createNode(0,2253);
	UA_Nodestore_insertNode(nsCtx, n1, NULL);
	UA_Node* n2 = createNode(0,2255);
	UA_Nodestore_insertNode(nsCtx, n2, NULL);
	UA_Node* n3 = createNode(0,2257);
	UA_Nodestore_insertNode(nsCtx, n3, NULL);
	UA_Node* n4 = createNode(0,2200);
	UA_Nodestore_insertNode(nsCtx, n4, NULL);
	UA_Node* n5 = createNode(0,1);
	UA_Nodestore_insertNode(nsCtx, n5, NULL);

	UA_NodeId id = UA_NODEID_NUMERIC(0, 12);
	const UA_Node* nr = UA_Nodestore_getNode(nsCtx, &id);
	ck_assert_int_eq((uintptr_t)nr, 0);
	}
	END_TEST

	/************************************/
	/* Performance Profiling Test Cases */
	/************************************/

	#if UA_MULTITHREADING >= 200
	struct UA_NodeStoreProfileTest {
	UA_Int32 min_val;
	UA_Int32 max_val;
	UA_Int32 rounds;
	};

	static void profileGetThread(void arg) {
	struct UA_NodeStoreProfileTest test = (struct UA_NodeStoreProfileTest) arg;
	UA_NodeId id;
	UA_NodeId_init(&id);
	UA_Int32 max_val = test->max_val;
	for(UA_Int32 x = 0; x<test->rounds; x++) {
	for(UA_Int32 i=test->min_val; i<max_val; i++) {
	id.identifier.numeric = i+1;
	const UA_Node *n = UA_Nodestore_getNode(nsCtx, &id);
	UA_Nodestore_releaseNode(nsCtx, n);
	}
	}
	return NULL;
	}
	#endif

	#define N 1000 /* make bigger to test */

	START_TEST(profileGetDelete) {
	clock_t begin, end;
	begin = clock();

	for(UA_UInt32 i = 0; i < N; i++) {
	UA_Node *n = createNode(0,i+1);
	UA_Nodestore_insertNode(nsCtx, n, NULL);
	}

	#if UA_MULTITHREADING >= 200
	#define THREADS 4
	pthread_t t[THREADS];
	struct UA_NodeStoreProfileTest p[THREADS];
	for (int i = 0; i < THREADS; i++) {
	p[i] = (struct UA_NodeStoreProfileTest){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_NULL;
	for(size_t i = 0; i < N; i++) {
	id.identifier.numeric = (UA_UInt32)i+1;
	const UA_Node *node = UA_Nodestore_getNode(nsCtx, &id);
	UA_Nodestore_releaseNode(nsCtx, node);
	}
	end = clock();
	printf("Time for single-threaded %d create/get/delete in a namespace: %fs.\n", N,
	(double)(end - begin) / CLOCKS_PER_SEC);
	#endif
	}
	END_TEST

	static Suite * namespace_suite (void) {
	Suite *s = suite_create ("UA_NodeStore");

	TCase* tc_find = tcase_create ("Find");
	tcase_add_checked_fixture(tc_find, setup, teardown);
	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, failToFindNonExistentNodeInUA_NodeStoreWithSeveralEntries);
	tcase_add_test (tc_find, failToFindNodeInOtherUA_NodeStore);
	suite_add_tcase (s, tc_find);

	TCase *tc_replace = tcase_create("Replace");
	tcase_add_checked_fixture(tc_replace, setup, teardown);
	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_checked_fixture(tc_iterate, setup, teardown);
	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_checked_fixture(tc_profile, setup, teardown);
	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;
	}