diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/rps/test_service_rps_sampler_elem.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/rps/test_service_rps_sampler_elem.c')
-rw-r--r-- | src/rps/test_service_rps_sampler_elem.c | 224 |
1 files changed, 114 insertions, 110 deletions
diff --git a/src/rps/test_service_rps_sampler_elem.c b/src/rps/test_service_rps_sampler_elem.c index b6e3e36bf..706abf4f9 100644 --- a/src/rps/test_service_rps_sampler_elem.c +++ b/src/rps/test_service_rps_sampler_elem.c | |||
@@ -25,12 +25,13 @@ | |||
25 | #include "gnunet_util_lib.h" | 25 | #include "gnunet_util_lib.h" |
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__); \ |
29 | #define CHECK(c) { if (!(c)) ABORT (); } | 29 | return 1; } |
30 | #define CHECK(c) { if (! (c)) ABORT (); } | ||
30 | 31 | ||
31 | 32 | ||
32 | static int | 33 | static int |
33 | check() | 34 | check () |
34 | { | 35 | { |
35 | struct GNUNET_PeerIdentity pid0; | 36 | struct GNUNET_PeerIdentity pid0; |
36 | struct GNUNET_PeerIdentity pid1; | 37 | struct GNUNET_PeerIdentity pid1; |
@@ -40,152 +41,155 @@ check() | |||
40 | struct GNUNET_HashCode hash_code; | 41 | struct GNUNET_HashCode hash_code; |
41 | struct GNUNET_HashCode hash_code2; | 42 | struct GNUNET_HashCode hash_code2; |
42 | 43 | ||
43 | memset(&pid0, 1, sizeof(pid0)); | 44 | memset (&pid0, 1, sizeof(pid0)); |
44 | memset(&pid1, 0, sizeof(pid1)); | 45 | memset (&pid1, 0, sizeof(pid1)); |
45 | 46 | ||
46 | /* Check if creation and destruction of an | 47 | /* Check if creation and destruction of an |
47 | * (empty) sampler element works */ | 48 | * (empty) sampler element works */ |
48 | s_elem = RPS_sampler_elem_create(); | 49 | s_elem = RPS_sampler_elem_create (); |
49 | CHECK(NULL != s_elem); | 50 | CHECK (NULL != s_elem); |
50 | CHECK(EMPTY == s_elem->is_empty); | 51 | CHECK (EMPTY == s_elem->is_empty); |
51 | CHECK(NULL != &s_elem->auth_key); | 52 | CHECK (NULL != &s_elem->auth_key); |
52 | auth_key = s_elem->auth_key; | 53 | auth_key = s_elem->auth_key; |
53 | RPS_sampler_elem_destroy(s_elem); | 54 | RPS_sampler_elem_destroy (s_elem); |
54 | 55 | ||
55 | 56 | ||
56 | /* Check creation of another sampler element | 57 | /* Check creation of another sampler element |
57 | * yields another (random) key */ | 58 | * yields another (random) key */ |
58 | s_elem = RPS_sampler_elem_create(); | 59 | s_elem = RPS_sampler_elem_create (); |
59 | CHECK(NULL != s_elem); | 60 | CHECK (NULL != s_elem); |
60 | CHECK(EMPTY == s_elem->is_empty); | 61 | CHECK (EMPTY == s_elem->is_empty); |
61 | CHECK(NULL != &s_elem->auth_key); | 62 | CHECK (NULL != &s_elem->auth_key); |
62 | CHECK(auth_key.key != s_elem->auth_key.key); | 63 | 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)); | 64 | CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key, |
65 | GNUNET_CRYPTO_HASH_LENGTH)); | ||
64 | auth_key = s_elem->auth_key; | 66 | auth_key = s_elem->auth_key; |
65 | 67 | ||
66 | /* Check that reinitialisation | 68 | /* Check that reinitialisation |
67 | * yields another (random) key */ | 69 | * yields another (random) key */ |
68 | RPS_sampler_elem_reinit(s_elem); | 70 | RPS_sampler_elem_reinit (s_elem); |
69 | CHECK(NULL != s_elem); | 71 | CHECK (NULL != s_elem); |
70 | CHECK(EMPTY == s_elem->is_empty); | 72 | CHECK (EMPTY == s_elem->is_empty); |
71 | CHECK(NULL != &s_elem->auth_key); | 73 | CHECK (NULL != &s_elem->auth_key); |
72 | CHECK(auth_key.key != s_elem->auth_key.key); | 74 | 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)); | 75 | CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key, |
74 | RPS_sampler_elem_destroy(s_elem); | 76 | GNUNET_CRYPTO_HASH_LENGTH)); |
77 | RPS_sampler_elem_destroy (s_elem); | ||
75 | 78 | ||
76 | 79 | ||
77 | /* Check that input of single peer id | 80 | /* Check that input of single peer id |
78 | * sets valid values */ | 81 | * sets valid values */ |
79 | s_elem = RPS_sampler_elem_create(); | 82 | s_elem = RPS_sampler_elem_create (); |
80 | CHECK(EMPTY == s_elem->is_empty); | 83 | CHECK (EMPTY == s_elem->is_empty); |
81 | CHECK(NULL != &s_elem->auth_key); | 84 | CHECK (NULL != &s_elem->auth_key); |
82 | CHECK(auth_key.key != s_elem->auth_key.key); | 85 | CHECK (auth_key.key != s_elem->auth_key.key); |
83 | /* This fails only with minimal chance */ | 86 | /* This fails only with minimal chance */ |
84 | CHECK(0 != memcmp(auth_key.key, s_elem->auth_key.key, GNUNET_CRYPTO_HASH_LENGTH)); | 87 | CHECK (0 != memcmp (auth_key.key, s_elem->auth_key.key, |
88 | GNUNET_CRYPTO_HASH_LENGTH)); | ||
85 | auth_key = s_elem->auth_key; | 89 | auth_key = s_elem->auth_key; |
86 | 90 | ||
87 | /* Check also that the hash of the peer id changed | 91 | /* Check also that the hash of the peer id changed |
88 | * Also fails with minimal probability */ | 92 | * Also fails with minimal probability */ |
89 | hash_code = s_elem->peer_id_hash; | 93 | hash_code = s_elem->peer_id_hash; |
90 | RPS_sampler_elem_next(s_elem, &pid0); | 94 | RPS_sampler_elem_next (s_elem, &pid0); |
91 | CHECK(0 == memcmp(&pid0, | 95 | CHECK (0 == memcmp (&pid0, |
92 | &s_elem->peer_id, | 96 | &s_elem->peer_id, |
93 | sizeof(struct GNUNET_PeerIdentity))); | 97 | sizeof(struct GNUNET_PeerIdentity))); |
94 | CHECK(0 != memcmp(&hash_code, | 98 | CHECK (0 != memcmp (&hash_code, |
95 | &s_elem->peer_id_hash, | 99 | &s_elem->peer_id_hash, |
96 | sizeof(struct GNUNET_HashCode))); | 100 | sizeof(struct GNUNET_HashCode))); |
97 | hash_code = s_elem->peer_id_hash; | 101 | hash_code = s_elem->peer_id_hash; |
98 | 102 | ||
99 | /* We can only check that the peer id is one of both inputs */ | 103 | /* We can only check that the peer id is one of both inputs */ |
100 | RPS_sampler_elem_next(s_elem, &pid1); | 104 | RPS_sampler_elem_next (s_elem, &pid1); |
101 | CHECK((0 == memcmp(&pid0, | 105 | CHECK ((0 == memcmp (&pid0, |
102 | &s_elem->peer_id, | 106 | &s_elem->peer_id, |
103 | sizeof(struct GNUNET_PeerIdentity))) || | 107 | sizeof(struct GNUNET_PeerIdentity))) || |
104 | (0 == memcmp(&pid1, | 108 | (0 == memcmp (&pid1, |
105 | &s_elem->peer_id, | 109 | &s_elem->peer_id, |
106 | sizeof(struct GNUNET_PeerIdentity)))); | 110 | sizeof(struct GNUNET_PeerIdentity)))); |
107 | 111 | ||
108 | /* Check that hash stayed the same when peer id did not change */ | 112 | /* Check that hash stayed the same when peer id did not change */ |
109 | if (0 == memcmp(&pid0, | 113 | if (0 == memcmp (&pid0, |
110 | &s_elem->peer_id, | 114 | &s_elem->peer_id, |
111 | sizeof(struct GNUNET_PeerIdentity))) | 115 | sizeof(struct GNUNET_PeerIdentity))) |
112 | { | 116 | { |
113 | CHECK(0 == memcmp(&hash_code, | 117 | CHECK (0 == memcmp (&hash_code, |
114 | &s_elem->peer_id_hash, | 118 | &s_elem->peer_id_hash, |
115 | sizeof(struct GNUNET_HashCode))); | 119 | sizeof(struct GNUNET_HashCode))); |
116 | } | 120 | } |
117 | else /* Check that hash changed */ | 121 | else /* Check that hash changed */ |
118 | { | 122 | { |
119 | CHECK(0 != memcmp(&hash_code, | 123 | CHECK (0 != memcmp (&hash_code, |
120 | &s_elem->peer_id_hash, | 124 | &s_elem->peer_id_hash, |
121 | sizeof(struct GNUNET_HashCode))); | 125 | sizeof(struct GNUNET_HashCode))); |
122 | } | 126 | } |
123 | 127 | ||
124 | /* Check multiple inputs of same id | 128 | /* Check multiple inputs of same id |
125 | * hash should not change anymore */ | 129 | * hash should not change anymore */ |
126 | hash_code2 = s_elem->peer_id_hash; | 130 | hash_code2 = s_elem->peer_id_hash; |
127 | RPS_sampler_elem_next(s_elem, &pid0); | 131 | RPS_sampler_elem_next (s_elem, &pid0); |
128 | CHECK(0 == memcmp(&hash_code2, | 132 | CHECK (0 == memcmp (&hash_code2, |
129 | &s_elem->peer_id_hash, | 133 | &s_elem->peer_id_hash, |
130 | sizeof(struct GNUNET_HashCode))); | 134 | sizeof(struct GNUNET_HashCode))); |
131 | RPS_sampler_elem_next(s_elem, &pid1); | 135 | RPS_sampler_elem_next (s_elem, &pid1); |
132 | CHECK(0 == memcmp(&hash_code2, | 136 | CHECK (0 == memcmp (&hash_code2, |
133 | &s_elem->peer_id_hash, | 137 | &s_elem->peer_id_hash, |
134 | sizeof(struct GNUNET_HashCode))); | 138 | sizeof(struct GNUNET_HashCode))); |
135 | RPS_sampler_elem_next(s_elem, &pid0); | 139 | RPS_sampler_elem_next (s_elem, &pid0); |
136 | CHECK(0 == memcmp(&hash_code2, | 140 | CHECK (0 == memcmp (&hash_code2, |
137 | &s_elem->peer_id_hash, | 141 | &s_elem->peer_id_hash, |
138 | sizeof(struct GNUNET_HashCode))); | 142 | sizeof(struct GNUNET_HashCode))); |
139 | RPS_sampler_elem_next(s_elem, &pid0); | 143 | RPS_sampler_elem_next (s_elem, &pid0); |
140 | CHECK(0 == memcmp(&hash_code2, | 144 | CHECK (0 == memcmp (&hash_code2, |
141 | &s_elem->peer_id_hash, | 145 | &s_elem->peer_id_hash, |
142 | sizeof(struct GNUNET_HashCode))); | 146 | sizeof(struct GNUNET_HashCode))); |
143 | RPS_sampler_elem_next(s_elem, &pid0); | 147 | RPS_sampler_elem_next (s_elem, &pid0); |
144 | CHECK(0 == memcmp(&hash_code2, | 148 | CHECK (0 == memcmp (&hash_code2, |
145 | &s_elem->peer_id_hash, | 149 | &s_elem->peer_id_hash, |
146 | sizeof(struct GNUNET_HashCode))); | 150 | sizeof(struct GNUNET_HashCode))); |
147 | RPS_sampler_elem_next(s_elem, &pid1); | 151 | RPS_sampler_elem_next (s_elem, &pid1); |
148 | CHECK(0 == memcmp(&hash_code2, | 152 | CHECK (0 == memcmp (&hash_code2, |
149 | &s_elem->peer_id_hash, | 153 | &s_elem->peer_id_hash, |
150 | sizeof(struct GNUNET_HashCode))); | 154 | sizeof(struct GNUNET_HashCode))); |
151 | RPS_sampler_elem_next(s_elem, &pid1); | 155 | RPS_sampler_elem_next (s_elem, &pid1); |
152 | CHECK(0 == memcmp(&hash_code2, | 156 | CHECK (0 == memcmp (&hash_code2, |
153 | &s_elem->peer_id_hash, | 157 | &s_elem->peer_id_hash, |
154 | sizeof(struct GNUNET_HashCode))); | 158 | sizeof(struct GNUNET_HashCode))); |
155 | RPS_sampler_elem_next(s_elem, &pid1); | 159 | RPS_sampler_elem_next (s_elem, &pid1); |
156 | CHECK(0 == memcmp(&hash_code2, | 160 | CHECK (0 == memcmp (&hash_code2, |
157 | &s_elem->peer_id_hash, | 161 | &s_elem->peer_id_hash, |
158 | sizeof(struct GNUNET_HashCode))); | 162 | sizeof(struct GNUNET_HashCode))); |
159 | 163 | ||
160 | /* Check whether pid stayed the same all the time */ | 164 | /* Check whether pid stayed the same all the time */ |
161 | if (0 == memcmp(&hash_code, | 165 | if (0 == memcmp (&hash_code, |
162 | &hash_code2, | 166 | &hash_code2, |
163 | sizeof(struct GNUNET_HashCode))) | 167 | sizeof(struct GNUNET_HashCode))) |
164 | { | 168 | { |
165 | CHECK(0 == memcmp(&pid0, | 169 | CHECK (0 == memcmp (&pid0, |
166 | &s_elem->peer_id, | 170 | &s_elem->peer_id, |
167 | sizeof(struct GNUNET_PeerIdentity))); | 171 | sizeof(struct GNUNET_PeerIdentity))); |
168 | } | 172 | } |
169 | else | 173 | else |
170 | { | 174 | { |
171 | CHECK(0 == memcmp(&pid1, | 175 | CHECK (0 == memcmp (&pid1, |
172 | &s_elem->peer_id, | 176 | &s_elem->peer_id, |
173 | sizeof(struct GNUNET_PeerIdentity))); | 177 | sizeof(struct GNUNET_PeerIdentity))); |
174 | } | 178 | } |
175 | RPS_sampler_elem_destroy(s_elem); | 179 | RPS_sampler_elem_destroy (s_elem); |
176 | 180 | ||
177 | /* Check _set() */ | 181 | /* Check _set() */ |
178 | s_elem = RPS_sampler_elem_create(); | 182 | s_elem = RPS_sampler_elem_create (); |
179 | CHECK(NULL != s_elem); | 183 | CHECK (NULL != s_elem); |
180 | CHECK(EMPTY == s_elem->is_empty); | 184 | CHECK (EMPTY == s_elem->is_empty); |
181 | CHECK(NULL != &s_elem->auth_key); | 185 | CHECK (NULL != &s_elem->auth_key); |
182 | auth_key = s_elem->auth_key; | 186 | auth_key = s_elem->auth_key; |
183 | memset(&auth_key2, 0, sizeof(auth_key2)); | 187 | memset (&auth_key2, 0, sizeof(auth_key2)); |
184 | RPS_sampler_elem_set(s_elem, auth_key2); | 188 | RPS_sampler_elem_set (s_elem, auth_key2); |
185 | CHECK(0 == memcmp(auth_key2.key, | 189 | CHECK (0 == memcmp (auth_key2.key, |
186 | s_elem->auth_key.key, | 190 | s_elem->auth_key.key, |
187 | GNUNET_CRYPTO_HASH_LENGTH)); | 191 | GNUNET_CRYPTO_HASH_LENGTH)); |
188 | RPS_sampler_elem_destroy(s_elem); | 192 | RPS_sampler_elem_destroy (s_elem); |
189 | 193 | ||
190 | 194 | ||
191 | /* TODO: deterministic tests (use _set() to set auth_key) */ | 195 | /* TODO: deterministic tests (use _set() to set auth_key) */ |
@@ -194,15 +198,15 @@ check() | |||
194 | 198 | ||
195 | 199 | ||
196 | int | 200 | int |
197 | main(int argc, char *argv[]) | 201 | main (int argc, char *argv[]) |
198 | { | 202 | { |
199 | (void)argc; | 203 | (void) argc; |
200 | (void)argv; | 204 | (void) argv; |
201 | 205 | ||
202 | GNUNET_log_setup("test_service_rps_peers", | 206 | GNUNET_log_setup ("test_service_rps_peers", |
203 | "WARNING", | 207 | "WARNING", |
204 | NULL); | 208 | NULL); |
205 | return check(); | 209 | return check (); |
206 | } | 210 | } |
207 | 211 | ||
208 | /* end of test_service_rps_peers.c */ | 212 | /* end of test_service_rps_peers.c */ |