diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/util/test_container_bloomfilter.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/util/test_container_bloomfilter.c')
-rw-r--r-- | src/util/test_container_bloomfilter.c | 304 |
1 files changed, 152 insertions, 152 deletions
diff --git a/src/util/test_container_bloomfilter.c b/src/util/test_container_bloomfilter.c index 043eacafd..d295f465b 100644 --- a/src/util/test_container_bloomfilter.c +++ b/src/util/test_container_bloomfilter.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
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 util/test_container_bloomfilter.c | 21 | * @file util/test_container_bloomfilter.c |
22 | * @brief Testcase for the bloomfilter. | 22 | * @brief Testcase for the bloomfilter. |
@@ -35,26 +35,26 @@ | |||
35 | * Generate a random hashcode. | 35 | * Generate a random hashcode. |
36 | */ | 36 | */ |
37 | static void | 37 | static void |
38 | nextHC (struct GNUNET_HashCode *hc) | 38 | nextHC(struct GNUNET_HashCode *hc) |
39 | { | 39 | { |
40 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, hc); | 40 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, hc); |
41 | } | 41 | } |
42 | 42 | ||
43 | static int | 43 | static int |
44 | add_iterator (void *cls, struct GNUNET_HashCode *next) | 44 | add_iterator(void *cls, struct GNUNET_HashCode *next) |
45 | { | 45 | { |
46 | int *ret = cls; | 46 | int *ret = cls; |
47 | struct GNUNET_HashCode pos; | 47 | struct GNUNET_HashCode pos; |
48 | 48 | ||
49 | if (0 == (*ret)--) | 49 | if (0 == (*ret)--) |
50 | return GNUNET_NO; | 50 | return GNUNET_NO; |
51 | nextHC (&pos); | 51 | nextHC(&pos); |
52 | *next = pos; | 52 | *next = pos; |
53 | return GNUNET_YES; | 53 | return GNUNET_YES; |
54 | } | 54 | } |
55 | 55 | ||
56 | int | 56 | int |
57 | main (int argc, char *argv[]) | 57 | main(int argc, char *argv[]) |
58 | { | 58 | { |
59 | struct GNUNET_CONTAINER_BloomFilter *bf; | 59 | struct GNUNET_CONTAINER_BloomFilter *bf; |
60 | struct GNUNET_CONTAINER_BloomFilter *bfi; | 60 | struct GNUNET_CONTAINER_BloomFilter *bfi; |
@@ -66,186 +66,186 @@ main (int argc, char *argv[]) | |||
66 | char buf[SIZE]; | 66 | char buf[SIZE]; |
67 | struct stat sbuf; | 67 | struct stat sbuf; |
68 | 68 | ||
69 | GNUNET_log_setup ("test-container-bloomfilter", "WARNING", NULL); | 69 | GNUNET_log_setup("test-container-bloomfilter", "WARNING", NULL); |
70 | GNUNET_CRYPTO_seed_weak_random (1); | 70 | GNUNET_CRYPTO_seed_weak_random(1); |
71 | if (0 == stat (TESTFILE, &sbuf)) | 71 | if (0 == stat(TESTFILE, &sbuf)) |
72 | if (0 != unlink (TESTFILE)) | 72 | if (0 != unlink(TESTFILE)) |
73 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "unlink", TESTFILE); | 73 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "unlink", TESTFILE); |
74 | bf = GNUNET_CONTAINER_bloomfilter_load (TESTFILE, SIZE, K); | 74 | bf = GNUNET_CONTAINER_bloomfilter_load(TESTFILE, SIZE, K); |
75 | 75 | ||
76 | for (i = 0; i < 200; i++) | 76 | for (i = 0; i < 200; i++) |
77 | { | 77 | { |
78 | nextHC (&tmp); | 78 | nextHC(&tmp); |
79 | GNUNET_CONTAINER_bloomfilter_add (bf, &tmp); | 79 | GNUNET_CONTAINER_bloomfilter_add(bf, &tmp); |
80 | } | 80 | } |
81 | GNUNET_CRYPTO_seed_weak_random (1); | 81 | GNUNET_CRYPTO_seed_weak_random(1); |
82 | ok1 = 0; | 82 | ok1 = 0; |
83 | for (i = 0; i < 200; i++) | 83 | for (i = 0; i < 200; i++) |
84 | { | 84 | { |
85 | nextHC (&tmp); | 85 | nextHC(&tmp); |
86 | if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES) | 86 | if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES) |
87 | ok1++; | 87 | ok1++; |
88 | } | 88 | } |
89 | if (ok1 != 200) | 89 | if (ok1 != 200) |
90 | { | 90 | { |
91 | printf ("Got %d elements out of" | 91 | printf("Got %d elements out of" |
92 | "200 expected after insertion.\n", | 92 | "200 expected after insertion.\n", |
93 | ok1); | 93 | ok1); |
94 | GNUNET_CONTAINER_bloomfilter_free (bf); | 94 | GNUNET_CONTAINER_bloomfilter_free(bf); |
95 | return -1; | 95 | return -1; |
96 | } | 96 | } |
97 | if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_get_raw_data (bf, buf, SIZE)) | 97 | if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_get_raw_data(bf, buf, SIZE)) |
98 | { | 98 | { |
99 | GNUNET_CONTAINER_bloomfilter_free (bf); | 99 | GNUNET_CONTAINER_bloomfilter_free(bf); |
100 | return -1; | 100 | return -1; |
101 | } | 101 | } |
102 | 102 | ||
103 | GNUNET_CONTAINER_bloomfilter_free (bf); | 103 | GNUNET_CONTAINER_bloomfilter_free(bf); |
104 | 104 | ||
105 | bf = GNUNET_CONTAINER_bloomfilter_load (TESTFILE, SIZE, K); | 105 | bf = GNUNET_CONTAINER_bloomfilter_load(TESTFILE, SIZE, K); |
106 | GNUNET_assert (bf != NULL); | 106 | GNUNET_assert(bf != NULL); |
107 | bfi = GNUNET_CONTAINER_bloomfilter_init (buf, SIZE, K); | 107 | bfi = GNUNET_CONTAINER_bloomfilter_init(buf, SIZE, K); |
108 | GNUNET_assert (bfi != NULL); | 108 | GNUNET_assert(bfi != NULL); |
109 | 109 | ||
110 | GNUNET_CRYPTO_seed_weak_random (1); | 110 | GNUNET_CRYPTO_seed_weak_random(1); |
111 | ok1 = 0; | 111 | ok1 = 0; |
112 | ok2 = 0; | 112 | ok2 = 0; |
113 | for (i = 0; i < 200; i++) | 113 | for (i = 0; i < 200; i++) |
114 | { | 114 | { |
115 | nextHC (&tmp); | 115 | nextHC(&tmp); |
116 | if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES) | 116 | if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES) |
117 | ok1++; | 117 | ok1++; |
118 | if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES) | 118 | if (GNUNET_CONTAINER_bloomfilter_test(bfi, &tmp) == GNUNET_YES) |
119 | ok2++; | 119 | ok2++; |
120 | } | 120 | } |
121 | if (ok1 != 200) | 121 | if (ok1 != 200) |
122 | { | 122 | { |
123 | printf ("Got %d elements out of 200 " | 123 | printf("Got %d elements out of 200 " |
124 | "expected after reloading.\n", | 124 | "expected after reloading.\n", |
125 | ok1); | 125 | ok1); |
126 | GNUNET_CONTAINER_bloomfilter_free (bf); | 126 | GNUNET_CONTAINER_bloomfilter_free(bf); |
127 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 127 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
128 | return -1; | 128 | return -1; |
129 | } | 129 | } |
130 | 130 | ||
131 | if (ok2 != 200) | 131 | if (ok2 != 200) |
132 | { | 132 | { |
133 | printf ("Got %d elements out of 200 " | 133 | printf("Got %d elements out of 200 " |
134 | "expected after initialization.\n", | 134 | "expected after initialization.\n", |
135 | ok2); | 135 | ok2); |
136 | GNUNET_CONTAINER_bloomfilter_free (bf); | 136 | GNUNET_CONTAINER_bloomfilter_free(bf); |
137 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 137 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
138 | return -1; | 138 | return -1; |
139 | } | 139 | } |
140 | 140 | ||
141 | GNUNET_CRYPTO_seed_weak_random (1); | 141 | GNUNET_CRYPTO_seed_weak_random(1); |
142 | for (i = 0; i < 100; i++) | 142 | for (i = 0; i < 100; i++) |
143 | { | 143 | { |
144 | nextHC (&tmp); | 144 | nextHC(&tmp); |
145 | GNUNET_CONTAINER_bloomfilter_remove (bf, &tmp); | 145 | GNUNET_CONTAINER_bloomfilter_remove(bf, &tmp); |
146 | GNUNET_CONTAINER_bloomfilter_remove (bfi, &tmp); | 146 | GNUNET_CONTAINER_bloomfilter_remove(bfi, &tmp); |
147 | } | 147 | } |
148 | 148 | ||
149 | GNUNET_CRYPTO_seed_weak_random (1); | 149 | GNUNET_CRYPTO_seed_weak_random(1); |
150 | 150 | ||
151 | ok1 = 0; | 151 | ok1 = 0; |
152 | ok2 = 0; | 152 | ok2 = 0; |
153 | for (i = 0; i < 200; i++) | 153 | for (i = 0; i < 200; i++) |
154 | { | 154 | { |
155 | nextHC (&tmp); | 155 | nextHC(&tmp); |
156 | if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES) | 156 | if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES) |
157 | ok1++; | 157 | ok1++; |
158 | if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES) | 158 | if (GNUNET_CONTAINER_bloomfilter_test(bfi, &tmp) == GNUNET_YES) |
159 | ok2++; | 159 | ok2++; |
160 | } | 160 | } |
161 | 161 | ||
162 | if (ok1 != 100) | 162 | if (ok1 != 100) |
163 | { | 163 | { |
164 | printf ("Expected 100 elements in loaded filter" | 164 | printf("Expected 100 elements in loaded filter" |
165 | " after adding 200 and deleting 100, got %d\n", | 165 | " after adding 200 and deleting 100, got %d\n", |
166 | ok1); | 166 | ok1); |
167 | GNUNET_CONTAINER_bloomfilter_free (bf); | 167 | GNUNET_CONTAINER_bloomfilter_free(bf); |
168 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 168 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
169 | return -1; | 169 | return -1; |
170 | } | 170 | } |
171 | if (ok2 != 200) | 171 | if (ok2 != 200) |
172 | { | 172 | { |
173 | printf ("Expected 200 elements in initialized filter" | 173 | printf("Expected 200 elements in initialized filter" |
174 | " after adding 200 and deleting 100 " | 174 | " after adding 200 and deleting 100 " |
175 | "(which should do nothing for a filter not backed by a file), got %d\n", | 175 | "(which should do nothing for a filter not backed by a file), got %d\n", |
176 | ok2); | 176 | ok2); |
177 | GNUNET_CONTAINER_bloomfilter_free (bf); | 177 | GNUNET_CONTAINER_bloomfilter_free(bf); |
178 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 178 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
179 | return -1; | 179 | return -1; |
180 | } | 180 | } |
181 | 181 | ||
182 | GNUNET_CRYPTO_seed_weak_random (3); | 182 | GNUNET_CRYPTO_seed_weak_random(3); |
183 | 183 | ||
184 | GNUNET_CONTAINER_bloomfilter_clear (bf); | 184 | GNUNET_CONTAINER_bloomfilter_clear(bf); |
185 | falseok = 0; | 185 | falseok = 0; |
186 | for (i = 0; i < 1000; i++) | 186 | for (i = 0; i < 1000; i++) |
187 | { | 187 | { |
188 | nextHC (&tmp); | 188 | nextHC(&tmp); |
189 | if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES) | 189 | if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES) |
190 | falseok++; | 190 | falseok++; |
191 | } | 191 | } |
192 | if (falseok > 0) | 192 | if (falseok > 0) |
193 | { | 193 | { |
194 | GNUNET_CONTAINER_bloomfilter_free (bf); | 194 | GNUNET_CONTAINER_bloomfilter_free(bf); |
195 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 195 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
196 | return -1; | 196 | return -1; |
197 | } | 197 | } |
198 | 198 | ||
199 | if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_or (bf, buf, SIZE)) | 199 | if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_or(bf, buf, SIZE)) |
200 | { | 200 | { |
201 | GNUNET_CONTAINER_bloomfilter_free (bf); | 201 | GNUNET_CONTAINER_bloomfilter_free(bf); |
202 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 202 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
203 | return -1; | 203 | return -1; |
204 | } | 204 | } |
205 | 205 | ||
206 | GNUNET_CRYPTO_seed_weak_random (2); | 206 | GNUNET_CRYPTO_seed_weak_random(2); |
207 | i = 20; | 207 | i = 20; |
208 | GNUNET_CONTAINER_bloomfilter_resize (bfi, &add_iterator, &i, SIZE * 2, K); | 208 | GNUNET_CONTAINER_bloomfilter_resize(bfi, &add_iterator, &i, SIZE * 2, K); |
209 | 209 | ||
210 | GNUNET_CRYPTO_seed_weak_random (2); | 210 | GNUNET_CRYPTO_seed_weak_random(2); |
211 | i = 20; | 211 | i = 20; |
212 | GNUNET_CONTAINER_bloomfilter_resize (bf, &add_iterator, &i, SIZE * 2, K); | 212 | GNUNET_CONTAINER_bloomfilter_resize(bf, &add_iterator, &i, SIZE * 2, K); |
213 | GNUNET_CRYPTO_seed_weak_random (2); | 213 | GNUNET_CRYPTO_seed_weak_random(2); |
214 | 214 | ||
215 | ok1 = 0; | 215 | ok1 = 0; |
216 | ok2 = 0; | 216 | ok2 = 0; |
217 | for (i = 0; i < 20; i++) | 217 | for (i = 0; i < 20; i++) |
218 | { | 218 | { |
219 | nextHC (&tmp); | 219 | nextHC(&tmp); |
220 | if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES) | 220 | if (GNUNET_CONTAINER_bloomfilter_test(bf, &tmp) == GNUNET_YES) |
221 | ok1++; | 221 | ok1++; |
222 | if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES) | 222 | if (GNUNET_CONTAINER_bloomfilter_test(bfi, &tmp) == GNUNET_YES) |
223 | ok2++; | 223 | ok2++; |
224 | } | 224 | } |
225 | 225 | ||
226 | if (ok1 != 20) | 226 | if (ok1 != 20) |
227 | { | 227 | { |
228 | printf ("Expected 20 elements in resized file-backed filter" | 228 | printf("Expected 20 elements in resized file-backed filter" |
229 | " after adding 20, got %d\n", | 229 | " after adding 20, got %d\n", |
230 | ok1); | 230 | ok1); |
231 | GNUNET_CONTAINER_bloomfilter_free (bf); | 231 | GNUNET_CONTAINER_bloomfilter_free(bf); |
232 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 232 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
233 | return -1; | 233 | return -1; |
234 | } | 234 | } |
235 | if (ok2 != 20) | 235 | if (ok2 != 20) |
236 | { | 236 | { |
237 | printf ("Expected 20 elements in resized filter" | 237 | printf("Expected 20 elements in resized filter" |
238 | " after adding 20, got %d\n", | 238 | " after adding 20, got %d\n", |
239 | ok2); | 239 | ok2); |
240 | GNUNET_CONTAINER_bloomfilter_free (bf); | 240 | GNUNET_CONTAINER_bloomfilter_free(bf); |
241 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 241 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
242 | return -1; | 242 | return -1; |
243 | } | 243 | } |
244 | 244 | ||
245 | 245 | ||
246 | GNUNET_CONTAINER_bloomfilter_free (bf); | 246 | GNUNET_CONTAINER_bloomfilter_free(bf); |
247 | GNUNET_CONTAINER_bloomfilter_free (bfi); | 247 | GNUNET_CONTAINER_bloomfilter_free(bfi); |
248 | 248 | ||
249 | GNUNET_break (0 == unlink (TESTFILE)); | 249 | GNUNET_break(0 == unlink(TESTFILE)); |
250 | return 0; | 250 | return 0; |
251 | } | 251 | } |