1/* 2 * Copyright (C) 2011, 2012 Internet Systems Consortium, Inc. ("ISC") 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH 9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 10 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, 11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 14 * PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17/* $Id$ */ 18 19/*! \file */ 20 21#include <config.h> 22 23#include <atf-c.h> 24 25#include <stdlib.h> 26#include <time.h> 27#include <unistd.h> 28 29#include <isc/file.h> 30#include <isc/result.h> 31#include <isc/serial.h> 32#include <isc/stdtime.h> 33#include <isc/msgcat.h> 34 35#include <dns/db.h> 36#include <dns/rdatalist.h> 37#include <dns/rdataset.h> 38#include <dns/rdatasetiter.h> 39#include <dns/nsec3.h> 40 41#include "dnstest.h" 42 43static char tempname[11] = "dtXXXXXXXX"; 44 45static void 46callback(const char *file, int line, isc_assertiontype_t type, 47 const char *cond) 48{ 49 UNUSED(file); UNUSED(line); UNUSED(type); UNUSED(cond); 50 if (strcmp(tempname, "dtXXXXXXXX")) 51 unlink(tempname); 52 atf_tc_pass(); 53 exit(0); 54} 55 56static dns_db_t *db1 = NULL, *db2 = NULL; 57static dns_dbversion_t *v1 = NULL, *v2 = NULL; 58 59static void 60setup_db() { 61 isc_result_t result; 62 result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone, 63 dns_rdataclass_in, 0, NULL, &db1); 64 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 65 dns_db_newversion(db1, &v1); 66 67 result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone, 68 dns_rdataclass_in, 0, NULL, &db2); 69 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 70 dns_db_newversion(db2, &v2); 71} 72 73static void 74close_db() { 75 if (v1 != NULL) { 76 dns_db_closeversion(db1, &v1, ISC_FALSE); 77 ATF_REQUIRE_EQ(v1, NULL); 78 } 79 if (db1 != NULL) { 80 dns_db_detach(&db1); 81 ATF_REQUIRE_EQ(db1, NULL); 82 } 83 84 if (v2 != NULL) { 85 dns_db_closeversion(db2, &v2, ISC_FALSE); 86 ATF_REQUIRE_EQ(v2, NULL); 87 } 88 if (db2 != NULL) { 89 dns_db_detach(&db2); 90 ATF_REQUIRE_EQ(db2, NULL); 91 } 92} 93 94#define VERSION(callback) ((callback == NULL) ? v1 : v2) 95#define VERSIONP(callback) ((callback == NULL) ? &v1 : &v2) 96/* 97 * Individual unit tests 98 */ 99static void 100attachversion(isc_assertioncallback_t callback) { 101 isc_result_t result; 102 dns_dbversion_t *v = NULL; 103 104 result = dns_test_begin(NULL, ISC_FALSE); 105 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 106 107 setup_db(); 108 109 isc_assertion_setcallback(callback); 110 dns_db_attachversion(db1, VERSION(callback), &v); 111 if (callback != NULL) 112 atf_tc_fail("dns_db_attachversion did not assert"); 113 114 ATF_REQUIRE_EQ(v, v1); 115 dns_db_closeversion(db1, &v, ISC_FALSE); 116 ATF_REQUIRE_EQ(v, NULL); 117 118 close_db(); 119 dns_test_end(); 120} 121 122ATF_TC(attachversion); 123ATF_TC_HEAD(attachversion, tc) { 124 atf_tc_set_md_var(tc, "descr", "check dns_db_attachversion passes with matching db/verison"); 125} 126ATF_TC_BODY(attachversion, tc) { 127 128 UNUSED(tc); 129 130 attachversion(NULL); 131} 132 133ATF_TC(attachversion_bad); 134ATF_TC_HEAD(attachversion_bad, tc) { 135 atf_tc_set_md_var(tc, "descr", "check dns_db_attachversion aborts with mis-matching db/verison"); 136} 137ATF_TC_BODY(attachversion_bad, tc) { 138 139 UNUSED(tc); 140 141 attachversion(callback); 142} 143 144static void 145closeversion(isc_assertioncallback_t callback) { 146 isc_result_t result; 147 148 result = dns_test_begin(NULL, ISC_FALSE); 149 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 150 151 setup_db(); 152 153 isc_assertion_setcallback(callback); 154 dns_db_closeversion(db1, VERSIONP(callback), ISC_FALSE); 155 if (callback != NULL) 156 atf_tc_fail("dns_db_closeversion did not assert"); 157 ATF_REQUIRE_EQ(v1, NULL); 158 159 close_db(); 160 dns_test_end(); 161} 162 163ATF_TC(closeversion); 164ATF_TC_HEAD(closeversion, tc) { 165 atf_tc_set_md_var(tc, "descr", "check dns_db_closeversion passes with matching db/verison"); 166} 167ATF_TC_BODY(closeversion, tc) { 168 169 UNUSED(tc); 170 171 closeversion(NULL); 172} 173 174ATF_TC(closeversion_bad); 175ATF_TC_HEAD(closeversion_bad, tc) { 176 atf_tc_set_md_var(tc, "descr", "check dns_db_closeversion asserts with mis-matching db/verison"); 177} 178ATF_TC_BODY(closeversion_bad, tc) { 179 180 UNUSED(tc); 181 182 closeversion(callback); 183} 184 185static void 186find(isc_assertioncallback_t callback) { 187 isc_result_t result; 188 dns_rdataset_t rdataset; 189 dns_fixedname_t fixed; 190 191 result = dns_test_begin(NULL, ISC_FALSE); 192 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 193 194 setup_db(); 195 196 dns_rdataset_init(&rdataset); 197 dns_fixedname_init(&fixed); 198 199 isc_assertion_setcallback(callback); 200 result = dns_db_find(db1, dns_rootname, VERSION(callback), 201 dns_rdatatype_soa, 0, 0, NULL, 202 dns_fixedname_name(&fixed), &rdataset, NULL); 203 if (callback != NULL) 204 atf_tc_fail("dns_db_find did not assert"); 205 ATF_REQUIRE_EQ(result, DNS_R_NXDOMAIN); 206 207 close_db(); 208 209 dns_test_end(); 210} 211ATF_TC(find); 212ATF_TC_HEAD(find, tc) { 213 atf_tc_set_md_var(tc, "descr", "check dns_db_find passes with matching db/version"); 214} 215ATF_TC_BODY(find, tc) { 216 217 UNUSED(tc); 218 219 find(NULL); 220} 221 222ATF_TC(find_bad); 223ATF_TC_HEAD(find_bad, tc) { 224 atf_tc_set_md_var(tc, "descr", "check dns_db_find asserts with mis-matching db/version"); 225} 226ATF_TC_BODY(find_bad, tc) { 227 228 UNUSED(tc); 229 230 find(callback); 231} 232 233static void 234allrdatasets(isc_assertioncallback_t callback) { 235 isc_result_t result; 236 dns_dbnode_t *node = NULL; 237 dns_rdatasetiter_t *iterator = NULL; 238 239 result = dns_test_begin(NULL, ISC_FALSE); 240 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 241 242 setup_db(); 243 244 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); 245 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 246 247 isc_assertion_setcallback(callback); 248 result = dns_db_allrdatasets(db1, node, VERSION(callback), 0, 249 &iterator); 250 if (callback != NULL) 251 atf_tc_fail("dns_db_allrdatasets did not assert"); 252 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 253 254 dns_rdatasetiter_destroy(&iterator); 255 ATF_REQUIRE_EQ(iterator, NULL); 256 257 dns_db_detachnode(db1, &node); 258 ATF_REQUIRE_EQ(node, NULL); 259 260 close_db(); 261 262 dns_test_end(); 263} 264 265ATF_TC(allrdatasets); 266ATF_TC_HEAD(allrdatasets, tc) { 267 atf_tc_set_md_var(tc, "descr", "check dns_db_allrdatasets passes with matching db/version"); 268} 269ATF_TC_BODY(allrdatasets, tc) { 270 271 UNUSED(tc); 272 273 allrdatasets(NULL); 274} 275 276ATF_TC(allrdatasets_bad); 277ATF_TC_HEAD(allrdatasets_bad, tc) { 278 atf_tc_set_md_var(tc, "descr", "check dns_db_allrdatasets aborts with mis-matching db/version"); 279} 280ATF_TC_BODY(allrdatasets_bad, tc) { 281 282 UNUSED(tc); 283 284 allrdatasets(callback); 285} 286 287static void 288findrdataset(isc_assertioncallback_t callback) { 289 isc_result_t result; 290 dns_rdataset_t rdataset; 291 dns_fixedname_t fixed; 292 dns_dbnode_t *node = NULL; 293 294 result = dns_test_begin(NULL, ISC_FALSE); 295 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 296 297 setup_db(); 298 299 dns_rdataset_init(&rdataset); 300 dns_fixedname_init(&fixed); 301 302 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); 303 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 304 305 isc_assertion_setcallback(callback); 306 result = dns_db_findrdataset(db1, node, VERSION(callback), 307 dns_rdatatype_soa, 0, 0, &rdataset, NULL); 308 if (callback != NULL) 309 atf_tc_fail("dns_db_findrdataset did not assert"); 310 ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND); 311 312 dns_db_detachnode(db1, &node); 313 ATF_REQUIRE_EQ(node, NULL); 314 315 close_db(); 316 317 dns_test_end(); 318} 319 320ATF_TC(findrdataset); 321ATF_TC_HEAD(findrdataset, tc) { 322 atf_tc_set_md_var(tc, "descr", "check dns_db_findrdataset passes with matching db/version"); 323} 324ATF_TC_BODY(findrdataset, tc) { 325 326 UNUSED(tc); 327 328 findrdataset(NULL); 329} 330 331ATF_TC(findrdataset_bad); 332ATF_TC_HEAD(findrdataset_bad, tc) { 333 atf_tc_set_md_var(tc, "descr", "check dns_db_findrdataset aborts with mis-matching db/version"); 334} 335ATF_TC_BODY(findrdataset_bad, tc) { 336 337 UNUSED(tc); 338 339 findrdataset(callback); 340} 341 342static void 343deleterdataset(isc_assertioncallback_t callback) { 344 isc_result_t result; 345 dns_rdataset_t rdataset; 346 dns_fixedname_t fixed; 347 dns_dbnode_t *node = NULL; 348 349 result = dns_test_begin(NULL, ISC_FALSE); 350 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 351 352 setup_db(); 353 354 dns_rdataset_init(&rdataset); 355 dns_fixedname_init(&fixed); 356 357 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); 358 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 359 360 isc_assertion_setcallback(callback); 361 result = dns_db_deleterdataset(db1, node, VERSION(callback), 362 dns_rdatatype_soa, 0); 363 if (callback != NULL) 364 atf_tc_fail("dns_db_deleterdataset did not assert"); 365 ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED); 366 367 dns_db_detachnode(db1, &node); 368 ATF_REQUIRE_EQ(node, NULL); 369 370 close_db(); 371 372 dns_test_end(); 373} 374 375ATF_TC(deleterdataset); 376ATF_TC_HEAD(deleterdataset, tc) { 377 atf_tc_set_md_var(tc, "descr", "check dns_db_deleterdataset passes with matching db/version"); 378} 379ATF_TC_BODY(deleterdataset, tc) { 380 381 UNUSED(tc); 382 383 deleterdataset(NULL); 384} 385 386ATF_TC(deleterdataset_bad); 387ATF_TC_HEAD(deleterdataset_bad, tc) { 388 atf_tc_set_md_var(tc, "descr", "check dns_db_deleterdataset aborts with mis-matching db/version"); 389} 390ATF_TC_BODY(deleterdataset_bad, tc) { 391 392 UNUSED(tc); 393 394 deleterdataset(callback); 395} 396 397static void 398subtract(isc_assertioncallback_t callback) { 399 isc_result_t result; 400 dns_rdataset_t rdataset; 401 dns_fixedname_t fixed; 402 dns_dbnode_t *node = NULL; 403 dns_rdatalist_t rdatalist; 404 405 result = dns_test_begin(NULL, ISC_FALSE); 406 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 407 408 setup_db(); 409 410 dns_rdataset_init(&rdataset); 411 dns_rdatalist_init(&rdatalist); 412 dns_fixedname_init(&fixed); 413 414 rdatalist.rdclass = dns_rdataclass_in; 415 416 result = dns_rdatalist_tordataset(&rdatalist, &rdataset); 417 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 418 419 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); 420 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 421 422 isc_assertion_setcallback(callback); 423 result = dns_db_subtractrdataset(db1, node, VERSION(callback), 424 &rdataset, 0, NULL); 425 if (callback != NULL) 426 atf_tc_fail("dns_db_dns_db_subtractrdataset did not assert"); 427 ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED); 428 429 dns_db_detachnode(db1, &node); 430 ATF_REQUIRE_EQ(node, NULL); 431 432 close_db(); 433 434 dns_test_end(); 435} 436 437ATF_TC(subtractrdataset); 438ATF_TC_HEAD(subtractrdataset, tc) { 439 atf_tc_set_md_var(tc, "descr", "check dns_db_subtractrdataset passes with matching db/version"); 440} 441ATF_TC_BODY(subtractrdataset, tc) { 442 443 UNUSED(tc); 444 445 subtract(NULL); 446} 447 448ATF_TC(subtractrdataset_bad); 449ATF_TC_HEAD(subtractrdataset_bad, tc) { 450 atf_tc_set_md_var(tc, "descr", "check dns_db_subtractrdataset aborts with mis-matching db/version"); 451} 452ATF_TC_BODY(subtractrdataset_bad, tc) { 453 454 UNUSED(tc); 455 456 subtract(callback); 457} 458 459static void 460dump(isc_assertioncallback_t callback) { 461 isc_result_t result; 462 FILE *f = NULL; 463 464 result = dns_test_begin(NULL, ISC_FALSE); 465 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 466 467 setup_db(); 468 469 result = isc_file_openunique(tempname, &f); 470 fclose(f); 471 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 472 473 isc_assertion_setcallback(callback); 474 result = dns_db_dump(db1, VERSION(callback), tempname); 475 (void)unlink(tempname); 476 if (callback != NULL) 477 atf_tc_fail("dns_db_dump did not assert"); 478 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 479 480 close_db(); 481 482 dns_test_end(); 483} 484 485ATF_TC(dump); 486ATF_TC_HEAD(dump, tc) { 487 atf_tc_set_md_var(tc, "descr", "check dns_db_dump passes with matching db/version"); 488} 489ATF_TC_BODY(dump, tc) { 490 491 UNUSED(tc); 492 493 dump(NULL); 494} 495 496ATF_TC(dump_bad); 497ATF_TC_HEAD(dump_bad, tc) { 498 atf_tc_set_md_var(tc, "descr", "check dns_db_dump aborts with mis-matching db/version"); 499} 500ATF_TC_BODY(dump_bad, tc) { 501 502 UNUSED(tc); 503 504 dump(callback); 505} 506 507static void 508addrdataset(isc_assertioncallback_t callback) { 509 isc_result_t result; 510 dns_rdataset_t rdataset; 511 dns_fixedname_t fixed; 512 dns_dbnode_t *node = NULL; 513 dns_rdatalist_t rdatalist; 514 515 result = dns_test_begin(NULL, ISC_FALSE); 516 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 517 518 setup_db(); 519 520 dns_rdataset_init(&rdataset); 521 dns_rdatalist_init(&rdatalist); 522 dns_fixedname_init(&fixed); 523 524 rdatalist.rdclass = dns_rdataclass_in; 525 526 result = dns_rdatalist_tordataset(&rdatalist, &rdataset); 527 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 528 529 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); 530 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 531 532 isc_assertion_setcallback(callback); 533 result = dns_db_addrdataset(db1, node, VERSION(callback), 0, &rdataset, 534 0, NULL); 535 if (callback != NULL) 536 atf_tc_fail("dns_db_adddataset did not assert"); 537 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 538 539 dns_db_detachnode(db1, &node); 540 ATF_REQUIRE_EQ(node, NULL); 541 542 close_db(); 543 544 dns_test_end(); 545} 546 547ATF_TC(addrdataset); 548ATF_TC_HEAD(addrdataset, tc) { 549 atf_tc_set_md_var(tc, "descr", "check dns_db_addrdataset passes with matching db/version"); 550} 551ATF_TC_BODY(addrdataset, tc) { 552 553 UNUSED(tc); 554 555 addrdataset(NULL); 556} 557 558ATF_TC(addrdataset_bad); 559ATF_TC_HEAD(addrdataset_bad, tc) { 560 atf_tc_set_md_var(tc, "descr", "check dns_db_addrdataset aborts with mis-matching db/version"); 561} 562ATF_TC_BODY(addrdataset_bad, tc) { 563 564 UNUSED(tc); 565 566 addrdataset(callback); 567} 568 569static void 570getnsec3parameters(isc_assertioncallback_t callback) { 571 isc_result_t result; 572 dns_hash_t hash; 573 isc_uint8_t flags; 574 isc_uint16_t iterations; 575 unsigned char salt[DNS_NSEC3_SALTSIZE]; 576 size_t salt_length = sizeof(salt); 577 578 result = dns_test_begin(NULL, ISC_FALSE); 579 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 580 581 setup_db(); 582 583 isc_assertion_setcallback(callback); 584 result = dns_db_getnsec3parameters(db1, VERSION(callback), &hash, 585 &flags, &iterations, salt, 586 &salt_length); 587 if (callback != NULL) 588 atf_tc_fail("dns_db_dump did not assert"); 589 ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND); 590 591 close_db(); 592 593 dns_test_end(); 594} 595 596ATF_TC(getnsec3parameters); 597ATF_TC_HEAD(getnsec3parameters, tc) { 598 atf_tc_set_md_var(tc, "descr", "check dns_db_getnsec3parameters passes with matching db/version"); 599} 600ATF_TC_BODY(getnsec3parameters, tc) { 601 602 UNUSED(tc); 603 604 getnsec3parameters(NULL); 605} 606 607ATF_TC(getnsec3parameters_bad); 608ATF_TC_HEAD(getnsec3parameters_bad, tc) { 609 atf_tc_set_md_var(tc, "descr", "check dns_db_getnsec3parameters aborts with mis-matching db/version"); 610} 611ATF_TC_BODY(getnsec3parameters_bad, tc) { 612 613 UNUSED(tc); 614 615 getnsec3parameters(callback); 616} 617 618static void 619resigned(isc_assertioncallback_t callback) { 620 isc_result_t result; 621 dns_rdataset_t rdataset, added; 622 dns_dbnode_t *node = NULL; 623 dns_rdatalist_t rdatalist; 624 dns_rdata_rrsig_t rrsig; 625 dns_rdata_t rdata = DNS_RDATA_INIT; 626 isc_buffer_t b; 627 unsigned char buf[1024]; 628 629 result = dns_test_begin(NULL, ISC_FALSE); 630 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 631 632 setup_db(); 633 634 /* 635 * Create a dummy RRSIG record and set a resigning time. 636 */ 637 dns_rdataset_init(&added); 638 dns_rdataset_init(&rdataset); 639 dns_rdatalist_init(&rdatalist); 640 isc_buffer_init(&b, buf, sizeof(buf)); 641 642 DNS_RDATACOMMON_INIT(&rrsig, dns_rdatatype_rrsig, dns_rdataclass_in); 643 rrsig.covered = dns_rdatatype_a; 644 rrsig.algorithm = 100; 645 rrsig.labels = 0; 646 rrsig.originalttl = 0; 647 rrsig.timeexpire = 3600; 648 rrsig.timesigned = 0; 649 rrsig.keyid = 0; 650 dns_name_init(&rrsig.signer, NULL); 651 dns_name_clone(dns_rootname, &rrsig.signer); 652 rrsig.siglen = 0; 653 rrsig.signature = NULL; 654 655 result = dns_rdata_fromstruct(&rdata, dns_rdataclass_in, 656 dns_rdatatype_rrsig, &rrsig, &b); 657 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 658 659 rdatalist.rdclass = dns_rdataclass_in; 660 rdatalist.type = dns_rdatatype_rrsig; 661 ISC_LIST_APPEND(rdatalist.rdata, &rdata, link); 662 663 result = dns_rdatalist_tordataset(&rdatalist, &rdataset); 664 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 665 666 rdataset.attributes |= DNS_RDATASETATTR_RESIGN; 667 rdataset.resign = 7200; 668 669 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node); 670 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 671 672 result = dns_db_addrdataset(db1, node, v1, 0, &rdataset, 0, &added); 673 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); 674 675 dns_db_detachnode(db1, &node); 676 ATF_REQUIRE_EQ(node, NULL); 677 678 isc_assertion_setcallback(callback); 679 dns_db_resigned(db1, &added, VERSION(callback)); 680 if (callback != NULL) 681 atf_tc_fail("dns_db_resigned did not assert"); 682 683 dns_rdataset_disassociate(&added); 684 685 close_db(); 686 687 dns_test_end(); 688} 689 690ATF_TC(resigned); 691ATF_TC_HEAD(resigned, tc) { 692 atf_tc_set_md_var(tc, "descr", "check dns_rdataset_resigned passes with matching db/version"); 693} 694ATF_TC_BODY(resigned, tc) { 695 696 UNUSED(tc); 697 698 resigned(NULL); 699} 700 701ATF_TC(resigned_bad); 702ATF_TC_HEAD(resigned_bad, tc) { 703 atf_tc_set_md_var(tc, "descr", "check dns_rdataset_resigned aborts with mis-matching db/version"); 704} 705ATF_TC_BODY(resigned_bad, tc) { 706 707 UNUSED(tc); 708 709 resigned(callback); 710} 711 712/* 713 * Main 714 */ 715ATF_TP_ADD_TCS(tp) { 716 ATF_TP_ADD_TC(tp, dump); 717 ATF_TP_ADD_TC(tp, dump_bad); 718 ATF_TP_ADD_TC(tp, find); 719 ATF_TP_ADD_TC(tp, find_bad); 720 ATF_TP_ADD_TC(tp, allrdatasets); 721 ATF_TP_ADD_TC(tp, allrdatasets_bad); 722 ATF_TP_ADD_TC(tp, findrdataset); 723 ATF_TP_ADD_TC(tp, findrdataset_bad); 724 ATF_TP_ADD_TC(tp, addrdataset); 725 ATF_TP_ADD_TC(tp, addrdataset_bad); 726 ATF_TP_ADD_TC(tp, deleterdataset); 727 ATF_TP_ADD_TC(tp, deleterdataset_bad); 728 ATF_TP_ADD_TC(tp, subtractrdataset); 729 ATF_TP_ADD_TC(tp, subtractrdataset_bad); 730 ATF_TP_ADD_TC(tp, attachversion); 731 ATF_TP_ADD_TC(tp, attachversion_bad); 732 ATF_TP_ADD_TC(tp, closeversion); 733 ATF_TP_ADD_TC(tp, closeversion_bad); 734 ATF_TP_ADD_TC(tp, getnsec3parameters); 735 ATF_TP_ADD_TC(tp, getnsec3parameters_bad); 736 ATF_TP_ADD_TC(tp, resigned); 737 ATF_TP_ADD_TC(tp, resigned_bad); 738 739 return (atf_no_error()); 740} 741