]> git.saurik.com Git - apple/network_cmds.git/blob - unbound/testcode/unitmain.c
projects / apple / network_cmds.git / blob
? search:


4673214adc048e7d08da104463b3df2ae15b5cc9
[apple/network_cmds.git] / unbound / testcode / unitmain.c
1 /*
2 * testcode/unitmain.c - unit test main program for unbound.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 *
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 */
36 /**
37 * \file
38 * Unit test main program. Calls all the other unit tests.
39 * Exits with code 1 on a failure. 0 if all unit tests are successfull.
40 */
41
42 #include "config.h"
43 #ifdef HAVE_OPENSSL_ERR_H
44 #include <openssl/err.h>
45 #endif
46
47 #ifdef HAVE_OPENSSL_RAND_H
48 #include <openssl/rand.h>
49 #endif
50
51 #ifdef HAVE_OPENSSL_CONF_H
52 #include <openssl/conf.h>
53 #endif
54
55 #ifdef HAVE_OPENSSL_ENGINE_H
56 #include <openssl/engine.h>
57 #endif
58
59 #ifdef HAVE_NSS
60 /* nss3 */
61 #include "nss.h"
62 #endif
63
64 #include "ldns/rrdef.h"
65 #include "ldns/keyraw.h"
66 #include "util/log.h"
67 #include "testcode/unitmain.h"
68
69 /** number of tests done */
70 int testcount = 0;
71
72 #include "util/alloc.h"
73 /** test alloc code */
74 static void
75 alloc_test(void) {
76 alloc_special_t *t1, *t2;
77 struct alloc_cache major, minor1, minor2;
78 int i;
79
80 unit_show_feature("alloc_special_obtain");
81 alloc_init(&major, NULL, 0);
82 alloc_init(&minor1, &major, 0);
83 alloc_init(&minor2, &major, 1);
84
85 t1 = alloc_special_obtain(&minor1);
86 alloc_clear(&minor1);
87
88 alloc_special_release(&minor2, t1);
89 t2 = alloc_special_obtain(&minor2);
90 unit_assert( t1 == t2 ); /* reused */
91 alloc_special_release(&minor2, t1);
92
93 for(i=0; i<100; i++) {
94 t1 = alloc_special_obtain(&minor1);
95 alloc_special_release(&minor2, t1);
96 }
97 if(0) {
98 alloc_stats(&minor1);
99 alloc_stats(&minor2);
100 alloc_stats(&major);
101 }
102 /* reuse happened */
103 unit_assert(minor1.num_quar + minor2.num_quar + major.num_quar == 11);
104
105 alloc_clear(&minor1);
106 alloc_clear(&minor2);
107 unit_assert(major.num_quar == 11);
108 alloc_clear(&major);
109 }
110
111 #include "util/net_help.h"
112 /** test net code */
113 static void
114 net_test(void)
115 {
116 const char* t4[] = {"\000\000\000\000",
117 "\200\000\000\000",
118 "\300\000\000\000",
119 "\340\000\000\000",
120 "\360\000\000\000",
121 "\370\000\000\000",
122 "\374\000\000\000",
123 "\376\000\000\000",
124 "\377\000\000\000",
125 "\377\200\000\000",
126 "\377\300\000\000",
127 "\377\340\000\000",
128 "\377\360\000\000",
129 "\377\370\000\000",
130 "\377\374\000\000",
131 "\377\376\000\000",
132 "\377\377\000\000",
133 "\377\377\200\000",
134 "\377\377\300\000",
135 "\377\377\340\000",
136 "\377\377\360\000",
137 "\377\377\370\000",
138 "\377\377\374\000",
139 "\377\377\376\000",
140 "\377\377\377\000",
141 "\377\377\377\200",
142 "\377\377\377\300",
143 "\377\377\377\340",
144 "\377\377\377\360",
145 "\377\377\377\370",
146 "\377\377\377\374",
147 "\377\377\377\376",
148 "\377\377\377\377",
149 "\377\377\377\377",
150 "\377\377\377\377",
151 };
152 unit_show_func("util/net_help.c", "str_is_ip6");
153 unit_assert( str_is_ip6("::") );
154 unit_assert( str_is_ip6("::1") );
155 unit_assert( str_is_ip6("2001:7b8:206:1:240:f4ff:fe37:8810") );
156 unit_assert( str_is_ip6("fe80::240:f4ff:fe37:8810") );
157 unit_assert( !str_is_ip6("0.0.0.0") );
158 unit_assert( !str_is_ip6("213.154.224.12") );
159 unit_assert( !str_is_ip6("213.154.224.255") );
160 unit_assert( !str_is_ip6("255.255.255.0") );
161 unit_show_func("util/net_help.c", "is_pow2");
162 unit_assert( is_pow2(0) );
163 unit_assert( is_pow2(1) );
164 unit_assert( is_pow2(2) );
165 unit_assert( is_pow2(4) );
166 unit_assert( is_pow2(8) );
167 unit_assert( is_pow2(16) );
168 unit_assert( is_pow2(1024) );
169 unit_assert( is_pow2(1024*1024) );
170 unit_assert( is_pow2(1024*1024*1024) );
171 unit_assert( !is_pow2(3) );
172 unit_assert( !is_pow2(5) );
173 unit_assert( !is_pow2(6) );
174 unit_assert( !is_pow2(7) );
175 unit_assert( !is_pow2(9) );
176 unit_assert( !is_pow2(10) );
177 unit_assert( !is_pow2(11) );
178 unit_assert( !is_pow2(17) );
179 unit_assert( !is_pow2(23) );
180 unit_assert( !is_pow2(257) );
181 unit_assert( !is_pow2(259) );
182
183 /* test addr_mask */
184 unit_show_func("util/net_help.c", "addr_mask");
185 if(1) {
186 struct sockaddr_in a4;
187 struct sockaddr_in6 a6;
188 socklen_t l4 = (socklen_t)sizeof(a4);
189 socklen_t l6 = (socklen_t)sizeof(a6);
190 int i;
191 a4.sin_family = AF_INET;
192 a6.sin6_family = AF_INET6;
193 for(i=0; i<35; i++) {
194 /* address 255.255.255.255 */
195 memcpy(&a4.sin_addr, "\377\377\377\377", 4);
196 addr_mask((struct sockaddr_storage*)&a4, l4, i);
197 unit_assert(memcmp(&a4.sin_addr, t4[i], 4) == 0);
198 }
199 memcpy(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", 16);
200 addr_mask((struct sockaddr_storage*)&a6, l6, 128);
201 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", 16) == 0);
202 addr_mask((struct sockaddr_storage*)&a6, l6, 122);
203 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\300", 16) == 0);
204 addr_mask((struct sockaddr_storage*)&a6, l6, 120);
205 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\000", 16) == 0);
206 addr_mask((struct sockaddr_storage*)&a6, l6, 64);
207 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\000\000\000\000\000\000\000\000", 16) == 0);
208 addr_mask((struct sockaddr_storage*)&a6, l6, 0);
209 unit_assert(memcmp(&a6.sin6_addr, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000", 16) == 0);
210 }
211
212 /* test addr_in_common */
213 unit_show_func("util/net_help.c", "addr_in_common");
214 if(1) {
215 struct sockaddr_in a4, b4;
216 struct sockaddr_in6 a6, b6;
217 socklen_t l4 = (socklen_t)sizeof(a4);
218 socklen_t l6 = (socklen_t)sizeof(a6);
219 int i;
220 a4.sin_family = AF_INET;
221 b4.sin_family = AF_INET;
222 a6.sin6_family = AF_INET6;
223 b6.sin6_family = AF_INET6;
224 memcpy(&a4.sin_addr, "abcd", 4);
225 memcpy(&b4.sin_addr, "abcd", 4);
226 unit_assert(addr_in_common((struct sockaddr_storage*)&a4, 32,
227 (struct sockaddr_storage*)&b4, 32, l4) == 32);
228 unit_assert(addr_in_common((struct sockaddr_storage*)&a4, 34,
229 (struct sockaddr_storage*)&b4, 32, l4) == 32);
230 for(i=0; i<=32; i++) {
231 unit_assert(addr_in_common(
232 (struct sockaddr_storage*)&a4, 32,
233 (struct sockaddr_storage*)&b4, i, l4) == i);
234 unit_assert(addr_in_common(
235 (struct sockaddr_storage*)&a4, i,
236 (struct sockaddr_storage*)&b4, 32, l4) == i);
237 unit_assert(addr_in_common(
238 (struct sockaddr_storage*)&a4, i,
239 (struct sockaddr_storage*)&b4, i, l4) == i);
240 }
241 for(i=0; i<=32; i++) {
242 memcpy(&a4.sin_addr, "\377\377\377\377", 4);
243 memcpy(&b4.sin_addr, t4[i], 4);
244 unit_assert(addr_in_common(
245 (struct sockaddr_storage*)&a4, 32,
246 (struct sockaddr_storage*)&b4, 32, l4) == i);
247 unit_assert(addr_in_common(
248 (struct sockaddr_storage*)&b4, 32,
249 (struct sockaddr_storage*)&a4, 32, l4) == i);
250 }
251 memcpy(&a6.sin6_addr, "abcdefghabcdefgh", 16);
252 memcpy(&b6.sin6_addr, "abcdefghabcdefgh", 16);
253 unit_assert(addr_in_common((struct sockaddr_storage*)&a6, 128,
254 (struct sockaddr_storage*)&b6, 128, l6) == 128);
255 unit_assert(addr_in_common((struct sockaddr_storage*)&a6, 129,
256 (struct sockaddr_storage*)&b6, 128, l6) == 128);
257 for(i=0; i<=128; i++) {
258 unit_assert(addr_in_common(
259 (struct sockaddr_storage*)&a6, 128,
260 (struct sockaddr_storage*)&b6, i, l6) == i);
261 unit_assert(addr_in_common(
262 (struct sockaddr_storage*)&a6, i,
263 (struct sockaddr_storage*)&b6, 128, l6) == i);
264 unit_assert(addr_in_common(
265 (struct sockaddr_storage*)&a6, i,
266 (struct sockaddr_storage*)&b6, i, l6) == i);
267 }
268 }
269 /* test sockaddr_cmp_addr */
270 unit_show_func("util/net_help.c", "sockaddr_cmp_addr");
271 if(1) {
272 struct sockaddr_storage a, b;
273 socklen_t alen = (socklen_t)sizeof(a);
274 socklen_t blen = (socklen_t)sizeof(b);
275 unit_assert(ipstrtoaddr("127.0.0.0", 53, &a, &alen));
276 unit_assert(ipstrtoaddr("127.255.255.255", 53, &b, &blen));
277 unit_assert(sockaddr_cmp_addr(&a, alen, &b, blen) < 0);
278 unit_assert(sockaddr_cmp_addr(&b, blen, &a, alen) > 0);
279 unit_assert(sockaddr_cmp_addr(&a, alen, &a, alen) == 0);
280 unit_assert(sockaddr_cmp_addr(&b, blen, &b, blen) == 0);
281 unit_assert(ipstrtoaddr("192.168.121.5", 53, &a, &alen));
282 unit_assert(sockaddr_cmp_addr(&a, alen, &b, blen) > 0);
283 unit_assert(sockaddr_cmp_addr(&b, blen, &a, alen) < 0);
284 unit_assert(sockaddr_cmp_addr(&a, alen, &a, alen) == 0);
285 unit_assert(ipstrtoaddr("2001:3578:ffeb::99", 53, &b, &blen));
286 unit_assert(sockaddr_cmp_addr(&b, blen, &b, blen) == 0);
287 unit_assert(sockaddr_cmp_addr(&a, alen, &b, blen) < 0);
288 unit_assert(sockaddr_cmp_addr(&b, blen, &a, alen) > 0);
289 }
290 /* test addr_is_ip4mapped */
291 unit_show_func("util/net_help.c", "addr_is_ip4mapped");
292 if(1) {
293 struct sockaddr_storage a;
294 socklen_t l = (socklen_t)sizeof(a);
295 unit_assert(ipstrtoaddr("12.13.14.15", 53, &a, &l));
296 unit_assert(!addr_is_ip4mapped(&a, l));
297 unit_assert(ipstrtoaddr("fe80::217:31ff:fe91:df", 53, &a, &l));
298 unit_assert(!addr_is_ip4mapped(&a, l));
299 unit_assert(ipstrtoaddr("ffff::217:31ff:fe91:df", 53, &a, &l));
300 unit_assert(!addr_is_ip4mapped(&a, l));
301 unit_assert(ipstrtoaddr("::ffff:31ff:fe91:df", 53, &a, &l));
302 unit_assert(!addr_is_ip4mapped(&a, l));
303 unit_assert(ipstrtoaddr("::fffe:fe91:df", 53, &a, &l));
304 unit_assert(!addr_is_ip4mapped(&a, l));
305 unit_assert(ipstrtoaddr("::ffff:127.0.0.1", 53, &a, &l));
306 unit_assert(addr_is_ip4mapped(&a, l));
307 unit_assert(ipstrtoaddr("::ffff:127.0.0.2", 53, &a, &l));
308 unit_assert(addr_is_ip4mapped(&a, l));
309 unit_assert(ipstrtoaddr("::ffff:192.168.0.2", 53, &a, &l));
310 unit_assert(addr_is_ip4mapped(&a, l));
311 unit_assert(ipstrtoaddr("2::ffff:192.168.0.2", 53, &a, &l));
312 unit_assert(!addr_is_ip4mapped(&a, l));
313 }
314 /* test addr_is_any */
315 unit_show_func("util/net_help.c", "addr_is_any");
316 if(1) {
317 struct sockaddr_storage a;
318 socklen_t l = (socklen_t)sizeof(a);
319 unit_assert(ipstrtoaddr("0.0.0.0", 53, &a, &l));
320 unit_assert(addr_is_any(&a, l));
321 unit_assert(ipstrtoaddr("0.0.0.0", 10053, &a, &l));
322 unit_assert(addr_is_any(&a, l));
323 unit_assert(ipstrtoaddr("0.0.0.0", 0, &a, &l));
324 unit_assert(addr_is_any(&a, l));
325 unit_assert(ipstrtoaddr("::0", 0, &a, &l));
326 unit_assert(addr_is_any(&a, l));
327 unit_assert(ipstrtoaddr("::0", 53, &a, &l));
328 unit_assert(addr_is_any(&a, l));
329 unit_assert(ipstrtoaddr("::1", 53, &a, &l));
330 unit_assert(!addr_is_any(&a, l));
331 unit_assert(ipstrtoaddr("2001:1667::1", 0, &a, &l));
332 unit_assert(!addr_is_any(&a, l));
333 unit_assert(ipstrtoaddr("2001::0", 0, &a, &l));
334 unit_assert(!addr_is_any(&a, l));
335 unit_assert(ipstrtoaddr("10.0.0.0", 0, &a, &l));
336 unit_assert(!addr_is_any(&a, l));
337 unit_assert(ipstrtoaddr("0.0.0.10", 0, &a, &l));
338 unit_assert(!addr_is_any(&a, l));
339 unit_assert(ipstrtoaddr("192.0.2.1", 0, &a, &l));
340 unit_assert(!addr_is_any(&a, l));
341 }
342 }
343
344 #include "util/config_file.h"
345 /** test config_file: cfg_parse_memsize */
346 static void
347 config_memsize_test(void)
348 {
349 size_t v = 0;
350 unit_show_func("util/config_file.c", "cfg_parse_memsize");
351 if(0) {
352 /* these emit errors */
353 unit_assert( cfg_parse_memsize("", &v) == 0);
354 unit_assert( cfg_parse_memsize("bla", &v) == 0);
355 unit_assert( cfg_parse_memsize("nop", &v) == 0);
356 unit_assert( cfg_parse_memsize("n0b", &v) == 0);
357 unit_assert( cfg_parse_memsize("gb", &v) == 0);
358 unit_assert( cfg_parse_memsize("b", &v) == 0);
359 unit_assert( cfg_parse_memsize("kb", &v) == 0);
360 unit_assert( cfg_parse_memsize("kk kb", &v) == 0);
361 }
362 unit_assert( cfg_parse_memsize("0", &v) && v==0);
363 unit_assert( cfg_parse_memsize("1", &v) && v==1);
364 unit_assert( cfg_parse_memsize("10", &v) && v==10);
365 unit_assert( cfg_parse_memsize("10b", &v) && v==10);
366 unit_assert( cfg_parse_memsize("5b", &v) && v==5);
367 unit_assert( cfg_parse_memsize("1024", &v) && v==1024);
368 unit_assert( cfg_parse_memsize("1k", &v) && v==1024);
369 unit_assert( cfg_parse_memsize("1K", &v) && v==1024);
370 unit_assert( cfg_parse_memsize("1Kb", &v) && v==1024);
371 unit_assert( cfg_parse_memsize("1kb", &v) && v==1024);
372 unit_assert( cfg_parse_memsize("1 kb", &v) && v==1024);
373 unit_assert( cfg_parse_memsize("10 kb", &v) && v==10240);
374 unit_assert( cfg_parse_memsize("2k", &v) && v==2048);
375 unit_assert( cfg_parse_memsize("2m", &v) && v==2048*1024);
376 unit_assert( cfg_parse_memsize("3M", &v) && v==3072*1024);
377 unit_assert( cfg_parse_memsize("40m", &v) && v==40960*1024);
378 unit_assert( cfg_parse_memsize("1G", &v) && v==1024*1024*1024);
379 unit_assert( cfg_parse_memsize("1 Gb", &v) && v==1024*1024*1024);
380 unit_assert( cfg_parse_memsize("0 Gb", &v) && v==0*1024*1024);
381 }
382
383 #include "util/rtt.h"
384 /** test RTT code */
385 static void
386 rtt_test(void)
387 {
388 int init = 376;
389 int i;
390 struct rtt_info r;
391 unit_show_func("util/rtt.c", "rtt_timeout");
392 rtt_init(&r);
393 /* initial value sensible */
394 unit_assert( rtt_timeout(&r) == init );
395 rtt_lost(&r, init);
396 unit_assert( rtt_timeout(&r) == init*2 );
397 rtt_lost(&r, init*2);
398 unit_assert( rtt_timeout(&r) == init*4 );
399 rtt_update(&r, 4000);
400 unit_assert( rtt_timeout(&r) >= 2000 );
401 rtt_lost(&r, rtt_timeout(&r) );
402 for(i=0; i<100; i++) {
403 rtt_lost(&r, rtt_timeout(&r) );
404 unit_assert( rtt_timeout(&r) > RTT_MIN_TIMEOUT-1);
405 unit_assert( rtt_timeout(&r) < RTT_MAX_TIMEOUT+1);
406 }
407 }
408
409 #include "services/cache/infra.h"
410 #include "util/config_file.h"
411
412 /* lookup and get key and data structs easily */
413 static struct infra_data* infra_lookup_host(struct infra_cache* infra,
414 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
415 size_t zonelen, int wr, time_t now, struct infra_key** k)
416 {
417 struct infra_data* d;
418 struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
419 zone, zonelen, wr);
420 if(!e) return NULL;
421 d = (struct infra_data*)e->data;
422 if(d->ttl < now) {
423 lock_rw_unlock(&e->lock);
424 return NULL;
425 }
426 *k = (struct infra_key*)e->key;
427 return d;
428 }
429
430 /** test host cache */
431 static void
432 infra_test(void)
433 {
434 struct sockaddr_storage one;
435 socklen_t onelen;
436 uint8_t* zone = (uint8_t*)"\007example\003com\000";
437 size_t zonelen = 13;
438 struct infra_cache* slab;
439 struct config_file* cfg = config_create();
440 time_t now = 0;
441 uint8_t edns_lame;
442 int vs, to;
443 struct infra_key* k;
444 struct infra_data* d;
445 int init = 376;
446
447 unit_show_feature("infra cache");
448 unit_assert(ipstrtoaddr("127.0.0.1", 53, &one, &onelen));
449
450 slab = infra_create(cfg);
451 unit_assert( infra_host(slab, &one, onelen, zone, zonelen, now,
452 &vs, &edns_lame, &to) );
453 unit_assert( vs == 0 && to == init && edns_lame == 0 );
454
455 unit_assert( infra_rtt_update(slab, &one, onelen, zone, zonelen, LDNS_RR_TYPE_A, -1, init, now) );
456 unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
457 now, &vs, &edns_lame, &to) );
458 unit_assert( vs == 0 && to == init*2 && edns_lame == 0 );
459
460 unit_assert( infra_edns_update(slab, &one, onelen, zone, zonelen, -1, now) );
461 unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
462 now, &vs, &edns_lame, &to) );
463 unit_assert( vs == -1 && to == init*2 && edns_lame == 1);
464
465 now += cfg->host_ttl + 10;
466 unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
467 now, &vs, &edns_lame, &to) );
468 unit_assert( vs == 0 && to == init && edns_lame == 0 );
469
470 unit_assert( infra_set_lame(slab, &one, onelen,
471 zone, zonelen, now, 0, 0, LDNS_RR_TYPE_A) );
472 unit_assert( (d=infra_lookup_host(slab, &one, onelen, zone, zonelen, 0, now, &k)) );
473 unit_assert( d->ttl == now+cfg->host_ttl );
474 unit_assert( d->edns_version == 0 );
475 unit_assert(!d->isdnsseclame && !d->rec_lame && d->lame_type_A &&
476 !d->lame_other);
477 lock_rw_unlock(&k->entry.lock);
478
479 /* test merge of data */
480 unit_assert( infra_set_lame(slab, &one, onelen,
481 zone, zonelen, now, 0, 0, LDNS_RR_TYPE_AAAA) );
482 unit_assert( (d=infra_lookup_host(slab, &one, onelen, zone, zonelen, 0, now, &k)) );
483 unit_assert(!d->isdnsseclame && !d->rec_lame && d->lame_type_A &&
484 d->lame_other);
485 lock_rw_unlock(&k->entry.lock);
486
487 /* test that noEDNS cannot overwrite known-yesEDNS */
488 now += cfg->host_ttl + 10;
489 unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
490 now, &vs, &edns_lame, &to) );
491 unit_assert( vs == 0 && to == init && edns_lame == 0 );
492
493 unit_assert( infra_edns_update(slab, &one, onelen, zone, zonelen, 0, now) );
494 unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
495 now, &vs, &edns_lame, &to) );
496 unit_assert( vs == 0 && to == init && edns_lame == 1 );
497
498 unit_assert( infra_edns_update(slab, &one, onelen, zone, zonelen, -1, now) );
499 unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
500 now, &vs, &edns_lame, &to) );
501 unit_assert( vs == 0 && to == init && edns_lame == 1 );
502
503 infra_delete(slab);
504 config_delete(cfg);
505 }
506
507 #include "util/random.h"
508 /** test randomness */
509 static void
510 rnd_test(void)
511 {
512 struct ub_randstate* r;
513 int num = 1000, i;
514 long int a[1000];
515 unsigned int seed = (unsigned)time(NULL);
516 unit_show_feature("ub_random");
517 printf("ub_random seed is %u\n", seed);
518 unit_assert( (r = ub_initstate(seed, NULL)) );
519 for(i=0; i<num; i++) {
520 a[i] = ub_random(r);
521 unit_assert(a[i] >= 0);
522 unit_assert((size_t)a[i] <= (size_t)0x7fffffff);
523 if(i > 5)
524 unit_assert(a[i] != a[i-1] || a[i] != a[i-2] ||
525 a[i] != a[i-3] || a[i] != a[i-4] ||
526 a[i] != a[i-5] || a[i] != a[i-6]);
527 }
528 a[0] = ub_random_max(r, 1);
529 unit_assert(a[0] >= 0 && a[0] < 1);
530 a[0] = ub_random_max(r, 10000);
531 unit_assert(a[0] >= 0 && a[0] < 10000);
532 for(i=0; i<num; i++) {
533 a[i] = ub_random_max(r, 10);
534 unit_assert(a[i] >= 0 && a[i] < 10);
535 }
536 ub_randfree(r);
537 }
538
539 void unit_show_func(const char* file, const char* func)
540 {
541 printf("test %s:%s\n", file, func);
542 }
543
544 void unit_show_feature(const char* feature)
545 {
546 printf("test %s functions\n", feature);
547 }
548
549 /**
550 * Main unit test program. Setup, teardown and report errors.
551 * @param argc: arg count.
552 * @param argv: array of commandline arguments.
553 * @return program failure if test fails.
554 */
555 int
556 main(int argc, char* argv[])
557 {
558 log_init(NULL, 0, NULL);
559 if(argc != 1) {
560 printf("usage: %s\n", argv[0]);
561 printf("\tperforms unit tests.\n");
562 return 1;
563 }
564 printf("Start of %s unit test.\n", PACKAGE_STRING);
565 #ifdef HAVE_SSL
566 ERR_load_crypto_strings();
567 # ifdef HAVE_OPENSSL_CONFIG
568 OPENSSL_config("unbound");
569 # endif
570 # ifdef USE_GOST
571 (void)sldns_key_EVP_load_gost_id();
572 # endif
573 #elif defined(HAVE_NSS)
574 if(NSS_NoDB_Init(".") != SECSuccess)
575 fatal_exit("could not init NSS");
576 #endif /* HAVE_SSL or HAVE_NSS*/
577 checklock_start();
578 neg_test();
579 rnd_test();
580 verify_test();
581 net_test();
582 config_memsize_test();
583 dname_test();
584 rtt_test();
585 anchors_test();
586 alloc_test();
587 regional_test();
588 lruhash_test();
589 slabhash_test();
590 infra_test();
591 ldns_test();
592 msgparse_test();
593 checklock_stop();
594 printf("%d checks ok.\n", testcount);
595 #ifdef HAVE_SSL
596 # if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST)
597 sldns_key_EVP_unload_gost();
598 # endif
599 # ifdef HAVE_OPENSSL_CONFIG
600 EVP_cleanup();
601 ENGINE_cleanup();
602 CONF_modules_free();
603 # endif
604 CRYPTO_cleanup_all_ex_data();
605 ERR_remove_state(0);
606 ERR_free_strings();
607 RAND_cleanup();
608 #elif defined(HAVE_NSS)
609 if(NSS_Shutdown() != SECSuccess)
610 fatal_exit("could not shutdown NSS");
611 #endif /* HAVE_SSL or HAVE_NSS */
612 #ifdef HAVE_PTHREAD
613 /* dlopen frees its thread specific state */
614 pthread_exit(NULL);
615 #endif
616 return 0;
617 }
mirror of network_cmds