← Back to branch summary

~kernevil/ubuntu/trusty/bind9/sdlz-hmac-keys

« back to all changes in this revision

Viewing changes to lib/dns/tests/master_test.c

  • Committer: Package Import Robot
  • Author(s): LaMont Jones, Matthew Grant, LaMont Jones
  • Date: 2012-10-29 08:37:49 UTC
  • mfrom: (1.9.2)
  • Revision ID: package-import@ubuntu.com-20121029083749-r9inpzl0yuj9xdlu
Tags: 1:9.8.4.dfsg-1
[Matthew Grant]

* Turn off dlopen as it was causing test compile failures.
* Add missing library .postrm files for debhelper

[LaMont Jones]

* New upstream version
* soname fixup
* Ack NMUs

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/dns/tests/master_test.c
1
1
/*
2
 
 * Copyright (C) 2011  Internet Systems Consortium, Inc. ("ISC")
 
2
 * Copyright (C) 2011, 2012  Internet Systems Consortium, Inc. ("ISC")
3
3
 *
4
4
 * Permission to use, copy, modify, and/or distribute this software for any
5
5
 * purpose with or without fee is hereby granted, provided that the above
14
14
 * PERFORMANCE OF THIS SOFTWARE.
15
15
 */
16
16
 
17
 
/* $Id: master_test.c,v 1.2.2.4 2011-07-08 22:57:25 smann Exp $ */
 
17
/* $Id$ */
18
18
 
19
19
/*! \file */
20
20
 
27
27
#include <dns/cache.h>
28
28
#include <dns/callbacks.h>
29
29
#include <dns/master.h>
 
30
#include <dns/masterdump.h>
30
31
#include <dns/name.h>
31
32
#include <dns/rdata.h>
 
33
#include <dns/rdatalist.h>
32
34
#include <dns/rdataset.h>
33
35
 
34
36
#include "dnstest.h"
38
40
 */
39
41
 
40
42
#define BUFLEN          255
41
 
#define BIGBUFLEN       (64 * 1024)
 
43
#define BIGBUFLEN       (70 * 1024)
42
44
#define TEST_ORIGIN     "test"
43
45
 
44
46
static isc_result_t
104
106
 */
105
107
 
106
108
/* Successful load test */
107
 
ATF_TC(master_load);
108
 
ATF_TC_HEAD(master_load, tc) {
 
109
ATF_TC(load);
 
110
ATF_TC_HEAD(load, tc) {
109
111
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() loads a "
110
112
                                       "valid master file and returns success");
111
113
}
112
 
ATF_TC_BODY(master_load, tc) {
 
114
ATF_TC_BODY(load, tc) {
113
115
        isc_result_t result;
114
116
 
115
117
        UNUSED(tc);
125
127
 
126
128
 
127
129
/* Unepxected end of file test */
128
 
ATF_TC(master_unexpected);
129
 
ATF_TC_HEAD(master_unexpected, tc) {
 
130
ATF_TC(unexpected);
 
131
ATF_TC_HEAD(unexpected, tc) {
130
132
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() returns "
131
133
                                       "DNS_R_UNEXPECTED when file ends "
132
134
                                       "too soon");
133
135
}
134
 
ATF_TC_BODY(master_unexpected, tc) {
 
136
ATF_TC_BODY(unexpected, tc) {
135
137
        isc_result_t result;
136
138
 
137
139
        UNUSED(tc);
147
149
 
148
150
 
149
151
/* No owner test */
150
 
ATF_TC(master_noowner);
151
 
ATF_TC_HEAD(master_noowner, tc) {
 
152
ATF_TC(noowner);
 
153
ATF_TC_HEAD(noowner, tc) {
152
154
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() accepts broken "
153
155
                                       "zones with no TTL for first record "
154
156
                                       "if it is an SOA");
155
157
}
156
 
ATF_TC_BODY(master_noowner, tc) {
 
158
ATF_TC_BODY(noowner, tc) {
157
159
        isc_result_t result;
158
160
 
159
161
        UNUSED(tc);
169
171
 
170
172
 
171
173
/* No TTL test */
172
 
ATF_TC(master_nottl);
173
 
ATF_TC_HEAD(master_nottl, tc) {
 
174
ATF_TC(nottl);
 
175
ATF_TC_HEAD(nottl, tc) {
174
176
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() returns "
175
177
                                       "DNS_R_NOOWNER when no owner name "
176
178
                                       "is specified");
177
179
}
178
180
 
179
 
ATF_TC_BODY(master_nottl, tc) {
 
181
ATF_TC_BODY(nottl, tc) {
180
182
        isc_result_t result;
181
183
 
182
184
        UNUSED(tc);
192
194
 
193
195
 
194
196
/* Bad class test */
195
 
ATF_TC(master_badclass);
196
 
ATF_TC_HEAD(master_badclass, tc) {
 
197
ATF_TC(badclass);
 
198
ATF_TC_HEAD(badclass, tc) {
197
199
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() returns "
198
200
                                       "DNS_R_BADCLASS when record class "
199
201
                                       "doesn't match zone class");
200
202
}
201
 
ATF_TC_BODY(master_badclass, tc) {
 
203
ATF_TC_BODY(badclass, tc) {
202
204
        isc_result_t result;
203
205
 
204
206
        UNUSED(tc);
212
214
        dns_test_end();
213
215
}
214
216
 
 
217
/* Too big rdata test */
 
218
ATF_TC(toobig);
 
219
ATF_TC_HEAD(toobig, tc) {
 
220
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() returns "
 
221
                                       "ISC_R_NOSPACE when record is too big");
 
222
}
 
223
ATF_TC_BODY(toobig, tc) {
 
224
        isc_result_t result;
 
225
 
 
226
        UNUSED(tc);
 
227
 
 
228
        result = dns_test_begin(NULL, ISC_FALSE);
 
229
        ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 
230
 
 
231
        result = test_master("testdata/master/master15.data");
 
232
        ATF_REQUIRE_EQ(result, ISC_R_NOSPACE);
 
233
 
 
234
        dns_test_end();
 
235
}
 
236
 
 
237
/* Maximum rdata test */
 
238
ATF_TC(maxrdata);
 
239
ATF_TC_HEAD(maxrdata, tc) {
 
240
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() returns "
 
241
                                       "ISC_R_SUCCESS when record is maximum "
 
242
                                       "size");
 
243
}
 
244
ATF_TC_BODY(maxrdata, tc) {
 
245
        isc_result_t result;
 
246
 
 
247
        UNUSED(tc);
 
248
 
 
249
        result = dns_test_begin(NULL, ISC_FALSE);
 
250
        ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 
251
 
 
252
        result = test_master("testdata/master/master16.data");
 
253
        ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 
254
 
 
255
        dns_test_end();
 
256
}
 
257
 
215
258
/* DNSKEY test */
216
 
ATF_TC(master_dnskey);
217
 
ATF_TC_HEAD(master_dnskey, tc) {
 
259
ATF_TC(dnskey);
 
260
ATF_TC_HEAD(dnskey, tc) {
218
261
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() understands "
219
262
                                       "DNSKEY with key material");
220
263
}
221
 
ATF_TC_BODY(master_dnskey, tc) {
 
264
ATF_TC_BODY(dnskey, tc) {
222
265
        isc_result_t result;
223
266
 
224
267
        UNUSED(tc);
234
277
 
235
278
 
236
279
/* DNSKEY with no key material test */
237
 
ATF_TC(master_dnsnokey);
238
 
ATF_TC_HEAD(master_dnsnokey, tc) {
 
280
ATF_TC(dnsnokey);
 
281
ATF_TC_HEAD(dnsnokey, tc) {
239
282
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() understands "
240
283
                                       "DNSKEY with no key material");
241
284
}
242
 
ATF_TC_BODY(master_dnsnokey, tc) {
 
285
ATF_TC_BODY(dnsnokey, tc) {
243
286
        isc_result_t result;
244
287
 
245
288
        UNUSED(tc);
254
297
}
255
298
 
256
299
/* Include test */
257
 
ATF_TC(master_include);
258
 
ATF_TC_HEAD(master_include, tc) {
 
300
ATF_TC(include);
 
301
ATF_TC_HEAD(include, tc) {
259
302
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() understands "
260
303
                                       "$INCLUDE");
261
304
}
262
 
ATF_TC_BODY(master_include, tc) {
 
305
ATF_TC_BODY(include, tc) {
263
306
        isc_result_t result;
264
307
 
265
308
        UNUSED(tc);
274
317
}
275
318
 
276
319
/* Include failure test */
277
 
ATF_TC(master_includefail);
278
 
ATF_TC_HEAD(master_includefail, tc) {
 
320
ATF_TC(includefail);
 
321
ATF_TC_HEAD(includefail, tc) {
279
322
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() understands "
280
323
                                       "$INCLUDE failures");
281
324
}
282
 
ATF_TC_BODY(master_includefail, tc) {
 
325
ATF_TC_BODY(includefail, tc) {
283
326
        isc_result_t result;
284
327
 
285
328
        UNUSED(tc);
295
338
 
296
339
 
297
340
/* Non-empty blank lines test */
298
 
ATF_TC(master_blanklines);
299
 
ATF_TC_HEAD(master_blanklines, tc) {
 
341
ATF_TC(blanklines);
 
342
ATF_TC_HEAD(blanklines, tc) {
300
343
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() handles "
301
344
                                       "non-empty blank lines");
302
345
}
303
 
ATF_TC_BODY(master_blanklines, tc) {
 
346
ATF_TC_BODY(blanklines, tc) {
304
347
        isc_result_t result;
305
348
 
306
349
        UNUSED(tc);
315
358
}
316
359
 
317
360
/* SOA leading zeroes test */
318
 
ATF_TC(master_leadingzero);
319
 
ATF_TC_HEAD(master_leadingzero, tc) {
 
361
ATF_TC(leadingzero);
 
362
ATF_TC_HEAD(leadingzero, tc) {
320
363
        atf_tc_set_md_var(tc, "descr", "dns_master_loadfile() allows "
321
364
                                       "leading zeroes in SOA");
322
365
}
323
 
ATF_TC_BODY(master_leadingzero, tc) {
 
366
ATF_TC_BODY(leadingzero, tc) {
324
367
        isc_result_t result;
325
368
 
326
369
        UNUSED(tc);
334
377
        dns_test_end();
335
378
}
336
379
 
 
380
ATF_TC(totext);
 
381
ATF_TC_HEAD(totext, tc) {
 
382
        atf_tc_set_md_var(tc, "descr", "masterfile totext tests");
 
383
}
 
384
ATF_TC_BODY(totext, tc) {
 
385
        isc_result_t result;
 
386
        dns_rdataset_t rdataset;
 
387
        dns_rdatalist_t rdatalist;
 
388
        isc_buffer_t target;
 
389
        unsigned char buf[BIGBUFLEN];
 
390
 
 
391
        UNUSED(tc);
 
392
 
 
393
        result = dns_test_begin(NULL, ISC_FALSE);
 
394
        ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 
395
 
 
396
        /* First, test with an empty rdataset */
 
397
        rdatalist.rdclass = dns_rdataclass_in;
 
398
        rdatalist.type = dns_rdatatype_none;
 
399
        rdatalist.covers = dns_rdatatype_none;
 
400
        rdatalist.ttl = 0;
 
401
        ISC_LIST_INIT(rdatalist.rdata);
 
402
        ISC_LINK_INIT(&rdatalist, link);
 
403
 
 
404
        dns_rdataset_init(&rdataset);
 
405
        result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
 
406
        ATF_CHECK_EQ(result, ISC_R_SUCCESS);
 
407
 
 
408
        isc_buffer_init(&target, buf, BIGBUFLEN);
 
409
        result = dns_master_rdatasettotext(dns_rootname,
 
410
                                           &rdataset, &dns_master_style_debug,
 
411
                                           &target);
 
412
        ATF_CHECK_EQ(result, ISC_R_SUCCESS);
 
413
        ATF_CHECK_EQ(isc_buffer_usedlength(&target), 0);
 
414
 
 
415
        /*
 
416
         * XXX: We will also need to add tests for dumping various
 
417
         * rdata types, classes, etc, and comparing the results against
 
418
         * known-good output.
 
419
         */
 
420
 
 
421
        dns_test_end();
 
422
}
 
423
 
337
424
/*
338
425
 * Main
339
426
 */
340
427
ATF_TP_ADD_TCS(tp) {
341
 
        ATF_TP_ADD_TC(tp, master_load);
342
 
        ATF_TP_ADD_TC(tp, master_unexpected);
343
 
        ATF_TP_ADD_TC(tp, master_noowner);
344
 
        ATF_TP_ADD_TC(tp, master_nottl);
345
 
        ATF_TP_ADD_TC(tp, master_badclass);
346
 
        ATF_TP_ADD_TC(tp, master_dnskey);
347
 
        ATF_TP_ADD_TC(tp, master_dnsnokey);
348
 
        ATF_TP_ADD_TC(tp, master_include);
349
 
        ATF_TP_ADD_TC(tp, master_includefail);
350
 
        ATF_TP_ADD_TC(tp, master_blanklines);
351
 
        ATF_TP_ADD_TC(tp, master_leadingzero);
 
428
        ATF_TP_ADD_TC(tp, load);
 
429
        ATF_TP_ADD_TC(tp, unexpected);
 
430
        ATF_TP_ADD_TC(tp, noowner);
 
431
        ATF_TP_ADD_TC(tp, nottl);
 
432
        ATF_TP_ADD_TC(tp, badclass);
 
433
        ATF_TP_ADD_TC(tp, dnskey);
 
434
        ATF_TP_ADD_TC(tp, dnsnokey);
 
435
        ATF_TP_ADD_TC(tp, include);
 
436
        ATF_TP_ADD_TC(tp, includefail);
 
437
        ATF_TP_ADD_TC(tp, blanklines);
 
438
        ATF_TP_ADD_TC(tp, leadingzero);
 
439
        ATF_TP_ADD_TC(tp, totext);
 
440
        ATF_TP_ADD_TC(tp, toobig);
 
441
        ATF_TP_ADD_TC(tp, maxrdata);
352
442
 
353
443
        return (atf_no_error());
354
444
}