diff options
Diffstat (limited to 'src/rps/test_service_rps_sampler_elem.c')
-rw-r--r-- | src/rps/test_service_rps_sampler_elem.c | 230 |
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 | ||
32 | static int | 32 | static int |
33 | check () | 33 | check() |
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 | ||
196 | int | 196 | int |
197 | main (int argc, char *argv[]) | 197 | main(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 */ |