[BACK]Return to dbversion_test.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / mpl / bind / dist / lib / dns / tests

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/external/mpl/bind/dist/lib/dns/tests/Attic/dbversion_test.c between version 1.1.1.4 and 1.1.1.5

version 1.1.1.4, 2019/09/05 19:27:40 version 1.1.1.5, 2020/05/24 19:36:45
Line 11 
Line 11 
  * information regarding copyright ownership.   * information regarding copyright ownership.
  */   */
   
 #include <config.h>  
   
 #if HAVE_CMOCKA  #if HAVE_CMOCKA
   
   #include <sched.h> /* IWYU pragma: keep */
   #include <setjmp.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <stddef.h>  #include <stddef.h>
 #include <setjmp.h>  
   
 #include <sched.h> /* IWYU pragma: keep */  
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
Line 35 
Line 32 
 #include <isc/util.h>  #include <isc/util.h>
   
 #include <dns/db.h>  #include <dns/db.h>
   #include <dns/nsec3.h>
 #include <dns/rdatalist.h>  #include <dns/rdatalist.h>
 #include <dns/rdataset.h>  #include <dns/rdataset.h>
 #include <dns/rdatasetiter.h>  #include <dns/rdatasetiter.h>
 #include <dns/nsec3.h>  
   
 #include "dnstest.h"  #include "dnstest.h"
   
Line 50  static dns_dbversion_t *v1 = NULL, *v2 =
Line 47  static dns_dbversion_t *v1 = NULL, *v2 =
  * The code below enables us to trap assertion failures for testing   * The code below enables us to trap assertion failures for testing
  * purposes. local_callback() is set as the callback function for   * purposes. local_callback() is set as the callback function for
  * isc_assertion_failed(). It calls mock_assert() so that CMOCKA   * isc_assertion_failed(). It calls mock_assert() so that CMOCKA
  * will be able to see it, then returns to the calling functon via   * will be able to see it, then returns to the calling function via
  * longjmp() so that the abort() call in isc_assertion_failed() will   * longjmp() so that the abort() call in isc_assertion_failed() will
  * never be reached. Use check_assertion() to check for assertions   * never be reached. Use check_assertion() to check for assertions
  * instead of expect_assert_failure().   * instead of expect_assert_failure().
  */   */
 jmp_buf assertion;  jmp_buf assertion;
   
 #define check_assertion(function_call)                          \  #define check_assertion(function_call)                        \
         do {                                                    \          do {                                                  \
                 const int r = setjmp(assertion);                \                  const int r = setjmp(assertion);              \
                 if (r == 0) {                                   \                  if (r == 0) {                                 \
                         expect_assert_failure(function_call);   \                          expect_assert_failure(function_call); \
                 }                                               \                  }                                             \
         } while(false);          } while (false);
   
 static void  static void
 local_callback(const char *file, int line, isc_assertiontype_t type,  local_callback(const char *file, int line, isc_assertiontype_t type,
                const char *cond)                 const char *cond) {
 {  
         UNUSED(type);          UNUSED(type);
   
         mock_assert(1, cond, file, line);          mock_assert(1, cond, file, line);
Line 86  _setup(void **state) {
Line 82  _setup(void **state) {
         res = dns_test_begin(NULL, false);          res = dns_test_begin(NULL, false);
         assert_int_equal(res, ISC_R_SUCCESS);          assert_int_equal(res, ISC_R_SUCCESS);
   
         res = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,          res = dns_db_create(dt_mctx, "rbt", dns_rootname, dns_dbtype_zone,
                                dns_rdataclass_in, 0, NULL, &db1);                              dns_rdataclass_in, 0, NULL, &db1);
         assert_int_equal(res, ISC_R_SUCCESS);          assert_int_equal(res, ISC_R_SUCCESS);
         dns_db_newversion(db1, &v1);          dns_db_newversion(db1, &v1);
         assert_non_null(v1);          assert_non_null(v1);
   
         res = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,          res = dns_db_create(dt_mctx, "rbt", dns_rootname, dns_dbtype_zone,
                                dns_rdataclass_in, 0, NULL, &db2);                              dns_rdataclass_in, 0, NULL, &db2);
         assert_int_equal(res, ISC_R_SUCCESS);          assert_int_equal(res, ISC_R_SUCCESS);
         dns_db_newversion(db2, &v2);          dns_db_newversion(db2, &v2);
         assert_non_null(v1);          assert_non_null(v1);
Line 181  find(void **state) {
Line 177  find(void **state) {
         name = dns_fixedname_initname(&fixed);          name = dns_fixedname_initname(&fixed);
   
         dns_rdataset_init(&rdataset);          dns_rdataset_init(&rdataset);
         res = dns_db_find(db1, dns_rootname, v1, dns_rdatatype_soa,          res = dns_db_find(db1, dns_rootname, v1, dns_rdatatype_soa, 0, 0, NULL,
                           0, 0, NULL, name, &rdataset, NULL);                            name, &rdataset, NULL);
         assert_int_equal(res, DNS_R_NXDOMAIN);          assert_int_equal(res, DNS_R_NXDOMAIN);
   
         if (dns_rdataset_isassociated(&rdataset)) {          if (dns_rdataset_isassociated(&rdataset)) {
Line 190  find(void **state) {
Line 186  find(void **state) {
         }          }
   
         dns_rdataset_init(&rdataset);          dns_rdataset_init(&rdataset);
         check_assertion(dns_db_find(db1, dns_rootname, v2,          check_assertion((void)dns_db_find(db1, dns_rootname, v2,
                                     dns_rdatatype_soa, 0, 0, NULL,                                            dns_rdatatype_soa, 0, 0, NULL, name,
                                     name, &rdataset, NULL));                                            &rdataset, NULL));
 }  }
   
 /*  /*
Line 220  allrdatasets(void **state) {
Line 216  allrdatasets(void **state) {
   
         dns_db_detachnode(db1, &node);          dns_db_detachnode(db1, &node);
         assert_null(node);          assert_null(node);
   
   
 }  }
   
 /*  /*
Line 240  findrdataset(void **state) {
Line 234  findrdataset(void **state) {
         assert_int_equal(res, ISC_R_SUCCESS);          assert_int_equal(res, ISC_R_SUCCESS);
   
         dns_rdataset_init(&rdataset);          dns_rdataset_init(&rdataset);
         res = dns_db_findrdataset(db1, node, v1, dns_rdatatype_soa,          res = dns_db_findrdataset(db1, node, v1, dns_rdatatype_soa, 0, 0,
                                      0, 0, &rdataset, NULL);                                    &rdataset, NULL);
         assert_int_equal(res, ISC_R_NOTFOUND);          assert_int_equal(res, ISC_R_NOTFOUND);
   
         if (dns_rdataset_isassociated(&rdataset)) {          if (dns_rdataset_isassociated(&rdataset)) {
Line 249  findrdataset(void **state) {
Line 243  findrdataset(void **state) {
         }          }
   
         dns_rdataset_init(&rdataset);          dns_rdataset_init(&rdataset);
         check_assertion(dns_db_findrdataset(db1, node, v2,          check_assertion(dns_db_findrdataset(db1, node, v2, dns_rdatatype_soa, 0,
                                             dns_rdatatype_soa, 0, 0,                                              0, &rdataset, NULL));
                                             &rdataset, NULL));  
   
         dns_db_detachnode(db1, &node);          dns_db_detachnode(db1, &node);
         assert_null(node);          assert_null(node);
Line 274  deleterdataset(void **state) {
Line 267  deleterdataset(void **state) {
         res = dns_db_deleterdataset(db1, node, v1, dns_rdatatype_soa, 0);          res = dns_db_deleterdataset(db1, node, v1, dns_rdatatype_soa, 0);
         assert_int_equal(res, DNS_R_UNCHANGED);          assert_int_equal(res, DNS_R_UNCHANGED);
   
         check_assertion(dns_db_deleterdataset(db1, node, v2,          check_assertion(
                                               dns_rdatatype_soa, 0));                  dns_db_deleterdataset(db1, node, v2, dns_rdatatype_soa, 0));
         dns_db_detachnode(db1, &node);          dns_db_detachnode(db1, &node);
         assert_null(node);          assert_null(node);
 }  }
Line 315  subtract(void **state) {
Line 308  subtract(void **state) {
         res = dns_rdatalist_tordataset(&rdatalist, &rdataset);          res = dns_rdatalist_tordataset(&rdatalist, &rdataset);
         assert_int_equal(res, ISC_R_SUCCESS);          assert_int_equal(res, ISC_R_SUCCESS);
   
         check_assertion(dns_db_subtractrdataset(db1, node, v2,          check_assertion(
                                                 &rdataset, 0, NULL));                  dns_db_subtractrdataset(db1, node, v2, &rdataset, 0, NULL));
   
         dns_db_detachnode(db1, &node);          dns_db_detachnode(db1, &node);
         assert_null(node);          assert_null(node);
Line 370  addrdataset(void **state) {
Line 363  addrdataset(void **state) {
         res = dns_db_addrdataset(db1, node, v1, 0, &rdataset, 0, NULL);          res = dns_db_addrdataset(db1, node, v1, 0, &rdataset, 0, NULL);
         assert_int_equal(res, ISC_R_SUCCESS);          assert_int_equal(res, ISC_R_SUCCESS);
   
         check_assertion(dns_db_addrdataset(db1, node, v2,          check_assertion(
                                            0, &rdataset, 0, NULL));                  dns_db_addrdataset(db1, node, v2, 0, &rdataset, 0, NULL));
   
         dns_db_detachnode(db1, &node);          dns_db_detachnode(db1, &node);
         assert_null(node);          assert_null(node);
Line 392  getnsec3parameters(void **state) {
Line 385  getnsec3parameters(void **state) {
   
         UNUSED(state);          UNUSED(state);
   
         res = dns_db_getnsec3parameters(db1, v1, &hash,          res = dns_db_getnsec3parameters(db1, v1, &hash, &flags, &iterations,
                                         &flags, &iterations, salt,                                          salt, &salt_length);
                                            &salt_length);  
         assert_int_equal(res, ISC_R_NOTFOUND);          assert_int_equal(res, ISC_R_NOTFOUND);
   
         check_assertion(dns_db_getnsec3parameters(db1, v2, &hash,          check_assertion(dns_db_getnsec3parameters(
                                                   &flags, &iterations,                  db1, v2, &hash, &flags, &iterations, salt, &salt_length));
                                                   salt, &salt_length));  
 }  }
   
 /*  /*
Line 475  main(void) {
Line 466  main(void) {
         const struct CMUnitTest tests[] = {          const struct CMUnitTest tests[] = {
                 cmocka_unit_test_setup_teardown(dump, _setup, _teardown),                  cmocka_unit_test_setup_teardown(dump, _setup, _teardown),
                 cmocka_unit_test_setup_teardown(find, _setup, _teardown),                  cmocka_unit_test_setup_teardown(find, _setup, _teardown),
                 cmocka_unit_test_setup_teardown(allrdatasets,                  cmocka_unit_test_setup_teardown(allrdatasets, _setup,
                                                 _setup, _teardown),                                                  _teardown),
                 cmocka_unit_test_setup_teardown(findrdataset,                  cmocka_unit_test_setup_teardown(findrdataset, _setup,
                                                 _setup, _teardown),                                                  _teardown),
                 cmocka_unit_test_setup_teardown(deleterdataset,                  cmocka_unit_test_setup_teardown(deleterdataset, _setup,
                                                 _setup, _teardown),                                                  _teardown),
                 cmocka_unit_test_setup_teardown(subtract,                  cmocka_unit_test_setup_teardown(subtract, _setup, _teardown),
                                                 _setup, _teardown),                  cmocka_unit_test_setup_teardown(addrdataset, _setup, _teardown),
                 cmocka_unit_test_setup_teardown(addrdataset,                  cmocka_unit_test_setup_teardown(getnsec3parameters, _setup,
                                                 _setup, _teardown),                                                  _teardown),
                 cmocka_unit_test_setup_teardown(getnsec3parameters,                  cmocka_unit_test_setup_teardown(resigned, _setup, _teardown),
                                                 _setup, _teardown),                  cmocka_unit_test_setup_teardown(attachversion, _setup,
                 cmocka_unit_test_setup_teardown(resigned,                                                  _teardown),
                                                 _setup, _teardown),                  cmocka_unit_test_setup_teardown(closeversion, _setup,
                 cmocka_unit_test_setup_teardown(attachversion,                                                  _teardown),
                                                 _setup, _teardown),  
                 cmocka_unit_test_setup_teardown(closeversion,  
                                                 _setup, _teardown),  
         };          };
   
         return (cmocka_run_group_tests(tests, NULL, NULL));          return (cmocka_run_group_tests(tests, NULL, NULL));
Line 508  main(void) {
Line 496  main(void) {
         return (0);          return (0);
 }  }
   
 #endif  #endif /* if HAVE_CMOCKA */

Legend:
Removed from v.1.1.1.4  
changed lines
  Added in v.1.1.1.5

CVSweb <webmaster@jp.NetBSD.org>