aboutsummaryrefslogtreecommitdiff
path: root/src/rps/test_service_rps_sampler_elem.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/rps/test_service_rps_sampler_elem.c')
-rw-r--r--src/rps/test_service_rps_sampler_elem.c230
1 files changed, 115 insertions, 115 deletions
diff --git a/src/rps/test_service_rps_sampler_elem.c b/src/rps/test_service_rps_sampler_elem.c
index 4e96b9bd1..b6e3e36bf 100644
--- a/src/rps/test_service_rps_sampler_elem.c
+++ b/src/rps/test_service_rps_sampler_elem.c
@@ -16,7 +16,7 @@
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file rps/test_service_rps_sampler_elem.c 21 * @file rps/test_service_rps_sampler_elem.c
22 * @brief testcase for gnunet-service-rps_sampler_elem.c 22 * @brief testcase for gnunet-service-rps_sampler_elem.c
@@ -26,11 +26,11 @@
26#include "gnunet-service-rps_sampler_elem.h" 26#include "gnunet-service-rps_sampler_elem.h"
27 27
28#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); return 1; } 28#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); return 1; }
29#define CHECK(c) { if (! (c)) ABORT(); } 29#define CHECK(c) { if (!(c)) ABORT (); }
30 30
31 31
32static int 32static int
33check () 33check()
34{ 34{
35 struct GNUNET_PeerIdentity pid0; 35 struct GNUNET_PeerIdentity pid0;
36 struct GNUNET_PeerIdentity pid1; 36 struct GNUNET_PeerIdentity pid1;
@@ -40,152 +40,152 @@ check ()
40 struct GNUNET_HashCode hash_code; 40 struct GNUNET_HashCode hash_code;
41 struct GNUNET_HashCode hash_code2; 41 struct GNUNET_HashCode hash_code2;
42 42
43 memset (&pid0, 1, sizeof (pid0)); 43 memset(&pid0, 1, sizeof(pid0));
44 memset (&pid1, 0, sizeof (pid1)); 44 memset(&pid1, 0, sizeof(pid1));
45 45
46 /* Check if creation and destruction of an 46 /* Check if creation and destruction of an
47 * (empty) sampler element works */ 47 * (empty) sampler element works */
48 s_elem = RPS_sampler_elem_create (); 48 s_elem = RPS_sampler_elem_create();
49 CHECK (NULL != s_elem); 49 CHECK(NULL != s_elem);
50 CHECK (EMPTY == s_elem->is_empty); 50 CHECK(EMPTY == s_elem->is_empty);
51 CHECK (NULL != &s_elem->auth_key); 51 CHECK(NULL != &s_elem->auth_key);
52 auth_key = s_elem->auth_key; 52 auth_key = s_elem->auth_key;
53 RPS_sampler_elem_destroy (s_elem); 53 RPS_sampler_elem_destroy(s_elem);
54 54
55 55
56 /* Check creation of another sampler element 56 /* Check creation of another sampler element
57 * yields another (random) key */ 57 * yields another (random) key */
58 s_elem = RPS_sampler_elem_create (); 58 s_elem = RPS_sampler_elem_create();
59 CHECK (NULL != s_elem); 59 CHECK(NULL != s_elem);
60 CHECK (EMPTY == s_elem->is_empty); 60 CHECK(EMPTY == s_elem->is_empty);
61 CHECK (NULL != &s_elem->auth_key); 61 CHECK(NULL != &s_elem->auth_key);
62 CHECK (auth_key.key != s_elem->auth_key.key); 62 CHECK(auth_key.key != s_elem->auth_key.key);
63 CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH)); 63 CHECK(0 != memcmp(auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH));
64 auth_key = s_elem->auth_key; 64 auth_key = s_elem->auth_key;
65 65
66 /* Check that reinitialisation 66 /* Check that reinitialisation
67 * yields another (random) key */ 67 * yields another (random) key */
68 RPS_sampler_elem_reinit (s_elem); 68 RPS_sampler_elem_reinit(s_elem);
69 CHECK (NULL != s_elem); 69 CHECK(NULL != s_elem);
70 CHECK (EMPTY == s_elem->is_empty); 70 CHECK(EMPTY == s_elem->is_empty);
71 CHECK (NULL != &s_elem->auth_key); 71 CHECK(NULL != &s_elem->auth_key);
72 CHECK (auth_key.key != s_elem->auth_key.key); 72 CHECK(auth_key.key != s_elem->auth_key.key);
73 CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH)); 73 CHECK(0 != memcmp(auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH));
74 RPS_sampler_elem_destroy (s_elem); 74 RPS_sampler_elem_destroy(s_elem);
75 75
76 76
77 /* Check that input of single peer id 77 /* Check that input of single peer id
78 * sets valid values */ 78 * sets valid values */
79 s_elem = RPS_sampler_elem_create (); 79 s_elem = RPS_sampler_elem_create();
80 CHECK (EMPTY == s_elem->is_empty); 80 CHECK(EMPTY == s_elem->is_empty);
81 CHECK (NULL != &s_elem->auth_key); 81 CHECK(NULL != &s_elem->auth_key);
82 CHECK (auth_key.key != s_elem->auth_key.key); 82 CHECK(auth_key.key != s_elem->auth_key.key);
83 /* This fails only with minimal chance */ 83 /* This fails only with minimal chance */
84 CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH)); 84 CHECK(0 != memcmp(auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH));
85 auth_key = s_elem->auth_key; 85 auth_key = s_elem->auth_key;
86 86
87 /* Check also that the hash of the peer id changed 87 /* Check also that the hash of the peer id changed
88 * Also fails with minimal probability */ 88 * Also fails with minimal probability */
89 hash_code = s_elem->peer_id_hash; 89 hash_code = s_elem->peer_id_hash;
90 RPS_sampler_elem_next (s_elem, &pid0); 90 RPS_sampler_elem_next(s_elem, &pid0);
91 CHECK (0 == memcmp (&pid0, 91 CHECK(0 == memcmp(&pid0,
92 &s_elem->peer_id, 92 &s_elem->peer_id,
93 sizeof (struct GNUNET_PeerIdentity))); 93 sizeof(struct GNUNET_PeerIdentity)));
94 CHECK (0 != memcmp (&hash_code, 94 CHECK(0 != memcmp(&hash_code,
95 &s_elem->peer_id_hash, 95 &s_elem->peer_id_hash,
96 sizeof (struct GNUNET_HashCode))); 96 sizeof(struct GNUNET_HashCode)));
97 hash_code = s_elem->peer_id_hash; 97 hash_code = s_elem->peer_id_hash;
98 98
99 /* We can only check that the peer id is one of both inputs */ 99 /* We can only check that the peer id is one of both inputs */
100 RPS_sampler_elem_next (s_elem, &pid1); 100 RPS_sampler_elem_next(s_elem, &pid1);
101 CHECK ( (0 == memcmp (&pid0, 101 CHECK((0 == memcmp(&pid0,
102 &s_elem->peer_id, 102 &s_elem->peer_id,
103 sizeof (struct GNUNET_PeerIdentity))) || 103 sizeof(struct GNUNET_PeerIdentity))) ||
104 (0 == memcmp (&pid1, 104 (0 == memcmp(&pid1,
105 &s_elem->peer_id, 105 &s_elem->peer_id,
106 sizeof (struct GNUNET_PeerIdentity))) ); 106 sizeof(struct GNUNET_PeerIdentity))));
107 107
108 /* Check that hash stayed the same when peer id did not change */ 108 /* Check that hash stayed the same when peer id did not change */
109 if (0 == memcmp (&pid0, 109 if (0 == memcmp(&pid0,
110 &s_elem->peer_id, 110 &s_elem->peer_id,
111 sizeof (struct GNUNET_PeerIdentity))) 111 sizeof(struct GNUNET_PeerIdentity)))
112 { 112 {
113 CHECK (0 == memcmp (&hash_code, 113 CHECK(0 == memcmp(&hash_code,
114 &s_elem->peer_id_hash, 114 &s_elem->peer_id_hash,
115 sizeof (struct GNUNET_HashCode))); 115 sizeof(struct GNUNET_HashCode)));
116 } 116 }
117 else /* Check that hash changed */ 117 else /* Check that hash changed */
118 { 118 {
119 CHECK (0 != memcmp (&hash_code, 119 CHECK(0 != memcmp(&hash_code,
120 &s_elem->peer_id_hash, 120 &s_elem->peer_id_hash,
121 sizeof (struct GNUNET_HashCode))); 121 sizeof(struct GNUNET_HashCode)));
122 } 122 }
123 123
124 /* Check multiple inputs of same id 124 /* Check multiple inputs of same id
125 * hash should not change anymore */ 125 * hash should not change anymore */
126 hash_code2 = s_elem->peer_id_hash; 126 hash_code2 = s_elem->peer_id_hash;
127 RPS_sampler_elem_next (s_elem, &pid0); 127 RPS_sampler_elem_next(s_elem, &pid0);
128 CHECK (0 == memcmp (&hash_code2, 128 CHECK(0 == memcmp(&hash_code2,
129 &s_elem->peer_id_hash, 129 &s_elem->peer_id_hash,
130 sizeof (struct GNUNET_HashCode))); 130 sizeof(struct GNUNET_HashCode)));
131 RPS_sampler_elem_next (s_elem, &pid1); 131 RPS_sampler_elem_next(s_elem, &pid1);
132 CHECK (0 == memcmp (&hash_code2, 132 CHECK(0 == memcmp(&hash_code2,
133 &s_elem->peer_id_hash, 133 &s_elem->peer_id_hash,
134 sizeof (struct GNUNET_HashCode))); 134 sizeof(struct GNUNET_HashCode)));
135 RPS_sampler_elem_next (s_elem, &pid0); 135 RPS_sampler_elem_next(s_elem, &pid0);
136 CHECK (0 == memcmp (&hash_code2, 136 CHECK(0 == memcmp(&hash_code2,
137 &s_elem->peer_id_hash, 137 &s_elem->peer_id_hash,
138 sizeof (struct GNUNET_HashCode))); 138 sizeof(struct GNUNET_HashCode)));
139 RPS_sampler_elem_next (s_elem, &pid0); 139 RPS_sampler_elem_next(s_elem, &pid0);
140 CHECK (0 == memcmp (&hash_code2, 140 CHECK(0 == memcmp(&hash_code2,
141 &s_elem->peer_id_hash, 141 &s_elem->peer_id_hash,
142 sizeof (struct GNUNET_HashCode))); 142 sizeof(struct GNUNET_HashCode)));
143 RPS_sampler_elem_next (s_elem, &pid0); 143 RPS_sampler_elem_next(s_elem, &pid0);
144 CHECK (0 == memcmp (&hash_code2, 144 CHECK(0 == memcmp(&hash_code2,
145 &s_elem->peer_id_hash, 145 &s_elem->peer_id_hash,
146 sizeof (struct GNUNET_HashCode))); 146 sizeof(struct GNUNET_HashCode)));
147 RPS_sampler_elem_next (s_elem, &pid1); 147 RPS_sampler_elem_next(s_elem, &pid1);
148 CHECK (0 == memcmp (&hash_code2, 148 CHECK(0 == memcmp(&hash_code2,
149 &s_elem->peer_id_hash, 149 &s_elem->peer_id_hash,
150 sizeof (struct GNUNET_HashCode))); 150 sizeof(struct GNUNET_HashCode)));
151 RPS_sampler_elem_next (s_elem, &pid1); 151 RPS_sampler_elem_next(s_elem, &pid1);
152 CHECK (0 == memcmp (&hash_code2, 152 CHECK(0 == memcmp(&hash_code2,
153 &s_elem->peer_id_hash, 153 &s_elem->peer_id_hash,
154 sizeof (struct GNUNET_HashCode))); 154 sizeof(struct GNUNET_HashCode)));
155 RPS_sampler_elem_next (s_elem, &pid1); 155 RPS_sampler_elem_next(s_elem, &pid1);
156 CHECK (0 == memcmp (&hash_code2, 156 CHECK(0 == memcmp(&hash_code2,
157 &s_elem->peer_id_hash, 157 &s_elem->peer_id_hash,
158 sizeof (struct GNUNET_HashCode))); 158 sizeof(struct GNUNET_HashCode)));
159 159
160 /* Check whether pid stayed the same all the time */ 160 /* Check whether pid stayed the same all the time */
161 if (0 == memcmp (&hash_code, 161 if (0 == memcmp(&hash_code,
162 &hash_code2, 162 &hash_code2,
163 sizeof (struct GNUNET_HashCode))) 163 sizeof(struct GNUNET_HashCode)))
164 { 164 {
165 CHECK (0 == memcmp (&pid0, 165 CHECK(0 == memcmp(&pid0,
166 &s_elem->peer_id, 166 &s_elem->peer_id,
167 sizeof (struct GNUNET_PeerIdentity))); 167 sizeof(struct GNUNET_PeerIdentity)));
168 } 168 }
169 else 169 else
170 { 170 {
171 CHECK (0 == memcmp (&pid1, 171 CHECK(0 == memcmp(&pid1,
172 &s_elem->peer_id, 172 &s_elem->peer_id,
173 sizeof (struct GNUNET_PeerIdentity))); 173 sizeof(struct GNUNET_PeerIdentity)));
174 } 174 }
175 RPS_sampler_elem_destroy (s_elem); 175 RPS_sampler_elem_destroy(s_elem);
176 176
177 /* Check _set() */ 177 /* Check _set() */
178 s_elem = RPS_sampler_elem_create (); 178 s_elem = RPS_sampler_elem_create();
179 CHECK (NULL != s_elem); 179 CHECK(NULL != s_elem);
180 CHECK (EMPTY == s_elem->is_empty); 180 CHECK(EMPTY == s_elem->is_empty);
181 CHECK (NULL != &s_elem->auth_key); 181 CHECK(NULL != &s_elem->auth_key);
182 auth_key = s_elem->auth_key; 182 auth_key = s_elem->auth_key;
183 memset (&auth_key2, 0, sizeof (auth_key2)); 183 memset(&auth_key2, 0, sizeof(auth_key2));
184 RPS_sampler_elem_set (s_elem, auth_key2); 184 RPS_sampler_elem_set(s_elem, auth_key2);
185 CHECK (0 == memcmp (auth_key2.key, 185 CHECK(0 == memcmp(auth_key2.key,
186 s_elem->auth_key.key, 186 s_elem->auth_key.key,
187 GNUNET_CRYPTO_HASH_LENGTH)); 187 GNUNET_CRYPTO_HASH_LENGTH));
188 RPS_sampler_elem_destroy (s_elem); 188 RPS_sampler_elem_destroy(s_elem);
189 189
190 190
191 /* TODO: deterministic tests (use _set() to set auth_key) */ 191 /* TODO: deterministic tests (use _set() to set auth_key) */
@@ -194,15 +194,15 @@ check ()
194 194
195 195
196int 196int
197main (int argc, char *argv[]) 197main(int argc, char *argv[])
198{ 198{
199 (void) argc; 199 (void)argc;
200 (void) argv; 200 (void)argv;
201 201
202 GNUNET_log_setup ("test_service_rps_peers", 202 GNUNET_log_setup("test_service_rps_peers",
203 "WARNING", 203 "WARNING",
204 NULL); 204 NULL);
205 return check (); 205 return check();
206} 206}
207 207
208/* end of test_service_rps_peers.c */ 208/* end of test_service_rps_peers.c */