1 files changed, 78 insertions, 61 deletions
diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c
index 482bcb997..1d82bd701 100644
--- a/src/util/test_container_multihashmap.c
+++ b/src/util/test_container_multihashmap.c
@@ -27,11 +27,16 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy (m); if (NULL != iter) GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); return 1; }
+#define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
-#define CHECK(c) { if (!(c)) ABORT (); }
+                  if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy (m); \
+                  if (NULL != \
+                      iter) \
+                    GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); \
+                  return 1; }
+#define CHECK(c) { if (! (c)) ABORT (); }
 static int
-testMap(int i)
+testMap (int i)
 {
  struct GNUNET_CONTAINER_MultiHashMap *m;
  struct GNUNET_HashCode k1;
@@ -41,77 +46,89 @@ testMap(int i)
  const char *ret;
  int j;
-  CHECK(NULL != (m = GNUNET_CONTAINER_multihashmap_create(i, GNUNET_NO)));
+  CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i, GNUNET_NO)));
-  memset(&k1, 0, sizeof(k1));
+  memset (&k1, 0, sizeof(k1));
-  memset(&k2, 1, sizeof(k2));
+  memset (&k2, 1, sizeof(k2));
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k1));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k2));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove(m, &k1, NULL));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k1, NULL));
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove(m, &k2, NULL));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k2, NULL));
-  CHECK(NULL == GNUNET_CONTAINER_multihashmap_get(m, &k1));
+  CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k1));
-  CHECK(NULL == GNUNET_CONTAINER_multihashmap_get(m, &k2));
+  CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k2));
-  CHECK(0 == GNUNET_CONTAINER_multihashmap_remove_all(m, &k1));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
-  CHECK(0 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK(0 == GNUNET_CONTAINER_multihashmap_iterate(m, NULL, NULL));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
-  CHECK(0 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k1, NULL, NULL));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
-  CHECK(GNUNET_OK ==
+  CHECK (GNUNET_OK ==
-        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v1",
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK(1 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
-  ret = GNUNET_CONTAINER_multihashmap_get(m, &k1);
+  ret = GNUNET_CONTAINER_multihashmap_get (m, &k1);
-  GNUNET_assert(ret != NULL);
+  GNUNET_assert (ret != NULL);
-  CHECK(0 == strcmp("v1", ret));
+  CHECK (0 == strcmp ("v1", ret));
-  CHECK(GNUNET_NO ==
+  CHECK (GNUNET_NO ==
-        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v1",
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
-  CHECK(1 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK(GNUNET_OK ==
+  CHECK (GNUNET_OK ==
-        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v2",
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK(GNUNET_OK ==
+  CHECK (GNUNET_OK ==
-        GNUNET_CONTAINER_multihashmap_put(m, &k1, "v3",
+         GNUNET_CONTAINER_multihashmap_put (m, &k1, "v3",
-                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  CHECK(3 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK(GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove(m, &k1, "v3"));
+  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
-  CHECK(2 == GNUNET_CONTAINER_multihashmap_size(m));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
-  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(m, &k1));
+  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k2));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
-  CHECK(2 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k1, NULL, NULL));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
-  CHECK(0 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k2, NULL, NULL));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k2, NULL, NULL));
-  CHECK(2 == GNUNET_CONTAINER_multihashmap_iterate(m, NULL, NULL));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(m);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (m);
-  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, &key_ret, (const void **)&ret));
+  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,
-  CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));
+                                                                    &key_ret,
-  CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, &key_ret, (const void **)&ret));
+                                                                    (const
-  CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));
+                                                                     void **) &
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));
+                                                                    ret));
-  GNUNET_free(iter);
+  CHECK (0 == memcmp (&key_ret, &k1, sizeof(key_ret)));
+  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                                    &key_ret,
+                                                                    (const
+                                                                     void **) &
+                                                                    ret));
+  CHECK (0 == memcmp (&key_ret, &k1, sizeof(key_ret)));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL,
+                                                                   NULL));
+  GNUNET_free (iter);
-  CHECK(2 == GNUNET_CONTAINER_multihashmap_remove_all(m, &k1));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
  for (j = 0; j < 1024; j++)
-    CHECK(GNUNET_OK ==
+    CHECK (GNUNET_OK ==
-          GNUNET_CONTAINER_multihashmap_put(m, &k1, "v2",
+           GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
-                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create(m);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (m);
-  for (j = 0; j < GNUNET_CONTAINER_multihashmap_size(m); j++)
+  for (j = 0; j < GNUNET_CONTAINER_multihashmap_size (m); j++)
-    CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));
+    CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,
-  CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));
+                                                                      NULL,
-  GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);
+                                                                      NULL));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL,
+                                                                   NULL));
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
-  GNUNET_CONTAINER_multihashmap_destroy(m);
+  GNUNET_CONTAINER_multihashmap_destroy (m);
  return 0;
 }
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
  int failureCount = 0;
  int i;
-  GNUNET_log_setup("test-container-multihashmap", "WARNING", NULL);
+  GNUNET_log_setup ("test-container-multihashmap", "WARNING", NULL);
  for (i = 1; i < 255; i++)
-    failureCount += testMap(i);
+    failureCount += testMap (i);
  if (failureCount != 0)
    return 1;
  return 0;

diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c index 482bcb997..1d82bd701 100644 --- a/src/util/test_container_multihashmap.c +++ b/src/util/test_container_multihashmap.c
@@ -27,11 +27,16 @@
27	#include "platform.h"	27	#include "platform.h"
28	#include "gnunet_util_lib.h"	28	#include "gnunet_util_lib.h"
29		29
30	#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy (m); if (NULL != iter) GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); return 1; }	30	#define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
31	#define CHECK(c) { if (!(c)) ABORT (); }	31	if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy (m); \
		32	if (NULL != \
		33	iter) \
		34	GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); \
		35	return 1; }
		36	#define CHECK(c) { if (! (c)) ABORT (); }
32		37
33	static int	38	static int
34	testMap(int i)	39	testMap (int i)
35	{	40	{
36	struct GNUNET_CONTAINER_MultiHashMap *m;	41	struct GNUNET_CONTAINER_MultiHashMap *m;
37	struct GNUNET_HashCode k1;	42	struct GNUNET_HashCode k1;
@@ -41,77 +46,89 @@ testMap(int i)
41	const char *ret;	46	const char *ret;
42	int j;	47	int j;
43		48
44	CHECK(NULL != (m = GNUNET_CONTAINER_multihashmap_create(i, GNUNET_NO)));	49	CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i, GNUNET_NO)));
45	memset(&k1, 0, sizeof(k1));	50	memset (&k1, 0, sizeof(k1));
46	memset(&k2, 1, sizeof(k2));	51	memset (&k2, 1, sizeof(k2));
47	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k1));	52	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
48	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k2));	53	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
49	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove(m, &k1, NULL));	54	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k1, NULL));
50	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove(m, &k2, NULL));	55	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k2, NULL));
51	CHECK(NULL == GNUNET_CONTAINER_multihashmap_get(m, &k1));	56	CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k1));
52	CHECK(NULL == GNUNET_CONTAINER_multihashmap_get(m, &k2));	57	CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k2));
53	CHECK(0 == GNUNET_CONTAINER_multihashmap_remove_all(m, &k1));	58	CHECK (0 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
54	CHECK(0 == GNUNET_CONTAINER_multihashmap_size(m));	59	CHECK (0 == GNUNET_CONTAINER_multihashmap_size (m));
55	CHECK(0 == GNUNET_CONTAINER_multihashmap_iterate(m, NULL, NULL));	60	CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
56	CHECK(0 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k1, NULL, NULL));	61	CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
57		62
58	CHECK(GNUNET_OK ==	63	CHECK (GNUNET_OK ==
59	GNUNET_CONTAINER_multihashmap_put(m, &k1, "v1",	64	GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
60	GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));	65	GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
61	CHECK(1 == GNUNET_CONTAINER_multihashmap_size(m));	66	CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
62	ret = GNUNET_CONTAINER_multihashmap_get(m, &k1);	67	ret = GNUNET_CONTAINER_multihashmap_get (m, &k1);
63	GNUNET_assert(ret != NULL);	68	GNUNET_assert (ret != NULL);
64	CHECK(0 == strcmp("v1", ret));	69	CHECK (0 == strcmp ("v1", ret));
65	CHECK(GNUNET_NO ==	70	CHECK (GNUNET_NO ==
66	GNUNET_CONTAINER_multihashmap_put(m, &k1, "v1",	71	GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
67	GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));	72	GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
68	CHECK(1 == GNUNET_CONTAINER_multihashmap_size(m));	73	CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
69	CHECK(GNUNET_OK ==	74	CHECK (GNUNET_OK ==
70	GNUNET_CONTAINER_multihashmap_put(m, &k1, "v2",	75	GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
71	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));	76	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
72	CHECK(GNUNET_OK ==	77	CHECK (GNUNET_OK ==
73	GNUNET_CONTAINER_multihashmap_put(m, &k1, "v3",	78	GNUNET_CONTAINER_multihashmap_put (m, &k1, "v3",
74	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));	79	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
75	CHECK(3 == GNUNET_CONTAINER_multihashmap_size(m));	80	CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
76	CHECK(GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove(m, &k1, "v3"));	81	CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
77	CHECK(2 == GNUNET_CONTAINER_multihashmap_size(m));	82	CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
78	CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(m, &k1));	83	CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
79	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(m, &k2));	84	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
80	CHECK(2 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k1, NULL, NULL));	85	CHECK (2 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
81	CHECK(0 == GNUNET_CONTAINER_multihashmap_get_multiple(m, &k2, NULL, NULL));	86	CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k2, NULL, NULL));
82	CHECK(2 == GNUNET_CONTAINER_multihashmap_iterate(m, NULL, NULL));	87	CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
83	iter = GNUNET_CONTAINER_multihashmap_iterator_create(m);	88	iter = GNUNET_CONTAINER_multihashmap_iterator_create (m);
84	CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, &key_ret, (const void **)&ret));	89	CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,
85	CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));	90	&key_ret,
86	CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, &key_ret, (const void **)&ret));	91	(const
87	CHECK(0 == memcmp(&key_ret, &k1, sizeof(key_ret)));	92	void **) &
88	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));	93	ret));
89	GNUNET_free(iter);	94	CHECK (0 == memcmp (&key_ret, &k1, sizeof(key_ret)));
		95	CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,
		96	&key_ret,
		97	(const
		98	void **) &
		99	ret));
		100	CHECK (0 == memcmp (&key_ret, &k1, sizeof(key_ret)));
		101	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL,
		102	NULL));
		103	GNUNET_free (iter);
90		104
91	CHECK(2 == GNUNET_CONTAINER_multihashmap_remove_all(m, &k1));	105	CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
92	for (j = 0; j < 1024; j++)	106	for (j = 0; j < 1024; j++)
93	CHECK(GNUNET_OK ==	107	CHECK (GNUNET_OK ==
94	GNUNET_CONTAINER_multihashmap_put(m, &k1, "v2",	108	GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
95	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));	109	GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
96	iter = GNUNET_CONTAINER_multihashmap_iterator_create(m);	110	iter = GNUNET_CONTAINER_multihashmap_iterator_create (m);
97	for (j = 0; j < GNUNET_CONTAINER_multihashmap_size(m); j++)	111	for (j = 0; j < GNUNET_CONTAINER_multihashmap_size (m); j++)
98	CHECK(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));	112	CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,
99	CHECK(GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, NULL));	113	NULL,
100	GNUNET_CONTAINER_multihashmap_iterator_destroy(iter);	114	NULL));
		115	CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL,
		116	NULL));
		117	GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
101		118
102	GNUNET_CONTAINER_multihashmap_destroy(m);	119	GNUNET_CONTAINER_multihashmap_destroy (m);
103	return 0;	120	return 0;
104	}	121	}
105		122
106	int	123	int
107	main(int argc, char *argv[])	124	main (int argc, char *argv[])
108	{	125	{
109	int failureCount = 0;	126	int failureCount = 0;
110	int i;	127	int i;
111		128
112	GNUNET_log_setup("test-container-multihashmap", "WARNING", NULL);	129	GNUNET_log_setup ("test-container-multihashmap", "WARNING", NULL);
113	for (i = 1; i < 255; i++)	130	for (i = 1; i < 255; i++)
114	failureCount += testMap(i);	131	failureCount += testMap (i);
115	if (failureCount != 0)	132	if (failureCount != 0)
116	return 1;	133	return 1;
117	return 0;	134	return 0;