upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-04-27 17:17:22 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
bind9/tests/isccfg/duration_test.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

209 lines
5.8 KiB
C
Raw Normal View History

Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
Update the copyright information in all files in the repository This commit converts the license handling to adhere to the REUSE specification. It specifically: 1. Adds used licnses to LICENSES/ directory 2. Add "isc" template for adding the copyright boilerplate 3. Changes all source files to include copyright and SPDX license header, this includes all the C sources, documentation, zone files, configuration files. There are notes in the doc/dev/copyrights file on how to add correct headers to the new files. 4. Handle the rest that can't be modified via .reuse/dep5 file. The binary (or otherwise unmodifiable) files could have license places next to them in <foo>.license file, but this would lead to cluttered repository and most of the files handled in the .reuse/dep5 file are system test files.
2021-06-03 02:37:05 -04:00
*
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
Include <inttypes.h> whenever including <cmocka.h> Development versions of cmocka require the intmax_t and uintmax_t types to be defined by the time the test code includes the <cmocka.h> header. These types are defined in the <stdint.h> header, which is included by the <inttypes.h> header, which in turn is already explicitly included by some of the programs in the tests/ directory. Ensure all programs in that directory that include the <cmocka.h> header also include the <inttypes.h> header to future-proof the code while keeping the change set minimal and the resulting code consistent. Also prevent explicitly including the <stdint.h> header in those programs as it is included by the <inttypes.h> header.
2023-05-18 09:12:23 -04:00
#include <inttypes.h>
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
#include <sched.h> /* IWYU pragma: keep */
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/buffer.h>
#include <isc/lex.h>
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/types.h>
#include <isc/util.h>
#include <isccfg/cfg.h>
#include <isccfg/grammar.h>
#include <isccfg/namedconf.h>
Move all the unit tests to /tests/<libname>/ The unit tests are now using a common base, which means that lib/dns/tests/ code now has to include lib/isc/include/isc/test.h and link with lib/isc/test.c and lib/ns/tests has to include both libisc and libdns parts. Instead of cross-linking code between the directories, move the /lib/<foo>/test.c to /tests/<foo>.c and /lib/<foo>/include/<foo>test.h to /tests/include/tests/<foo>.h and create a single libtest.la convenience library in /tests/. At the same time, move the /lib/<foo>/tests/ to /tests/<foo>/ (but keep it symlinked to the old location) and adjust paths accordingly. In few places, we are now using absolute paths instead of relative paths, because the directory level has changed. By moving the directories under the /tests/ directory, the test-related code is kept in a single place and we can avoid referencing files between libns->libdns->libisc which is unhealthy because they live in a separate Makefile-space. In the future, the /bin/tests/ should be merged to /tests/ and symlink kept, and the /fuzz/ directory moved to /tests/fuzz/.
2022-05-03 05:37:31 -04:00
#include <tests/isc.h>
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 04:56:42 -04:00
ISC_SETUP_TEST_IMPL(group) {
Convert all categories and modules into static lists Remove the complicated mechanism that could be (in theory) used by external libraries to register new categories and modules with statically defined lists in <isc/log.h>. This is similar to what we have done for <isc/result.h> result codes. All the libraries are now internal to BIND 9, so we don't need to provide a mechanism to register extra categories and modules.
2024-08-14 07:25:50 -04:00
isc_logconfig_t *logconfig = isc_logconfig_get();
Add isc_log_createandusechannel() function to simplify usage The new isc_log_createandusechannel() function combines following calls: isc_log_createchannel() isc_log_usechannel() calls into a single call that cannot fail and therefore can be used in places where we know this cannot fail thus simplifying the error handling.
2024-08-14 08:38:07 -04:00
isc_log_createandusechannel(
logconfig, "default_stderr", ISC_LOG_TOFILEDESC,
ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, 0,
ISC_LOGCATEGORY_DEFAULT, ISC_LOGMODULE_DEFAULT);
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 04:56:42 -04:00
return (0);
}
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
struct duration_conf {
const char *string;
uint32_t time;
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
const char *out;
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
};
typedef struct duration_conf duration_conf_t;
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
static void
output(void *closure, const char *text, int textlen) {
int r;
REQUIRE(textlen >= 0 && textlen < CFG_DURATION_MAXLEN);
r = snprintf(closure, CFG_DURATION_MAXLEN, "%s", text);
INSIST(r == textlen);
}
/* test cfg_obj_asduration() and cfg_print_duration() */
ISC_RUN_TEST_IMPL(duration) {
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
isc_result_t result;
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
/*
* When 'out' is NULL, the printed result is expected to be the same as
* the input 'string', compared by ignoring the case of the characters.
*/
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
duration_conf_t durations[] = {
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
{ .string = "unlimited", .time = 0 },
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
{ .string = "PT0S", .time = 0 },
{ .string = "PT42S", .time = 42 },
make ISO8601 duration parsing case-insensitive for robustness
2020-02-06 15:51:24 -05:00
{ .string = "PT10m", .time = 600 },
{ .string = "PT10m4S", .time = 604 },
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
{ .string = "PT3600S", .time = 3600 },
make ISO8601 duration parsing case-insensitive for robustness
2020-02-06 15:51:24 -05:00
{ .string = "pT2H", .time = 7200 },
{ .string = "Pt2H3S", .time = 7203 },
{ .string = "PT2h1m3s", .time = 7263 },
{ .string = "p7d", .time = 604800 },
{ .string = "P7DT2h", .time = 612000 },
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
{ .string = "P2W", .time = 1209600 },
{ .string = "P3M", .time = 8035200 },
{ .string = "P3MT10M", .time = 8035800 },
make ISO8601 duration parsing case-insensitive for robustness
2020-02-06 15:51:24 -05:00
{ .string = "p5y", .time = 157680000 },
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
{ .string = "P5YT2H", .time = 157687200 },
{ .string = "P1Y1M1DT1H1M1S", .time = 34304461 },
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
{ .string = "P99Y399M999DT3999H9999M2911754S",
.time = UINT32_MAX - 1 },
{ .string = "P99Y399M999DT3999H9999M2911755S",
.time = UINT32_MAX },
{ .string = "P4294967295Y4294967295M4294967295D"
"T4294967295H4294967295M4294967295S",
.time = UINT32_MAX },
{ .string = "PT4294967294S", .time = UINT32_MAX - 1 },
{ .string = "PT4294967295S", .time = UINT32_MAX },
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
{ .string = "0", .time = 0 },
{ .string = "30", .time = 30 },
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
{ .string = "42s", .time = 42, .out = "42" },
{ .string = "10m", .time = 600, .out = "600" },
{ .string = "2H", .time = 7200, .out = "7200" },
{ .string = "7d", .time = 604800, .out = "604800" },
{ .string = "2w", .time = 1209600, .out = "1209600" },
{ 0 }, /* Indicates that the remaining durations are invalid. */
{ .string = "PT4Y" },
{ .string = "P-4Y2M" },
{ .string = "P5H1M30S" },
{ .string = "P7Y4W" },
{ .string = "X7Y4M" },
{ .string = "T7H4M" },
{ .string = "1Y6M" },
{ .string = "PT4294967296S" },
{ .string = "PT99999999999S" },
{ .string = "P99999999999Y99999999999M99999999999D"
"T99999999999H99999999999M99999999999S" },
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
};
isc_buffer_t buf1;
cfg_parser_t *p1 = NULL;
cfg_obj_t *c1 = NULL;
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
bool must_fail = false;
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
for (size_t i = 0; i < ARRAY_SIZE(durations); i++) {
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
const cfg_listelt_t *element;
const cfg_obj_t *kasps = NULL;
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
const char cfg_tpl[] =
"dnssec-policy \"dp\"\n"
"{\nkeys {csk lifetime %s algorithm rsasha256;};\n};\n";
char conf[sizeof(cfg_tpl) + CFG_DURATION_MAXLEN] = { 0 };
char out[CFG_DURATION_MAXLEN] = { 0 };
cfg_printer_t pctx = { .f = output, .closure = out };
if (durations[i].string == NULL) {
must_fail = true;
continue;
}
snprintf(&conf[0], sizeof(conf), cfg_tpl, durations[i].string);
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
isc_buffer_init(&buf1, conf, strlen(conf) - 1);
isc_buffer_add(&buf1, strlen(conf) - 1);
/* Parse with default line numbering */
Remove logging context (isc_log_t) from the public namespace Now that the logging uses single global context, remove the isc_log_t from the public namespace.
2024-08-13 12:20:26 -04:00
result = cfg_parser_create(mctx, &p1);
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p1, &buf1, "text1", 0,
&cfg_type_namedconf, 0, &c1);
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
if (must_fail) {
assert_int_equal(result, DNS_R_BADTTL);
cfg_parser_destroy(&p1);
continue;
}
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
assert_int_equal(result, ISC_R_SUCCESS);
(void)cfg_map_get(c1, "dnssec-policy", &kasps);
assert_non_null(kasps);
for (element = cfg_list_first(kasps); element != NULL;
element = cfg_list_next(element))
{
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
const cfg_listelt_t *key_element;
const cfg_obj_t *lifetime = NULL;
const cfg_obj_t *keys = NULL;
const cfg_obj_t *key = NULL;
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
const cfg_obj_t *kopts = NULL;
cfg_obj_t *kconf = cfg_listelt_value(element);
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
int cmp;
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
assert_non_null(kconf);
kopts = cfg_tuple_get(kconf, "options");
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
result = cfg_map_get(kopts, "keys", &keys);
key_element = cfg_list_first(keys);
assert_non_null(key_element);
key = cfg_listelt_value(key_element);
assert_non_null(key);
lifetime = cfg_tuple_get(key, "lifetime");
assert_non_null(lifetime);
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
assert_int_equal(durations[i].time,
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
cfg_obj_asduration(lifetime));
cfg_print_duration_or_unlimited(&pctx, lifetime);
cmp = strncasecmp(durations[i].out != NULL
? durations[i].out
: durations[i].string,
out, strlen(durations[i].string));
assert_int_equal(cmp, 0);
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
}
cfg_obj_destroy(p1, &c1);
cfg_parser_destroy(&p1);
}
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 04:56:42 -04:00
ISC_TEST_LIST_START
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
Test cfg_print_duration() in duration_test.c Currently the 'duration_test' unit test checks only the cfg_obj_asduration() function. Extend the test so it checks also the reverse operation using the cfg_print_duration() function, which is used in named-checkconf.
2022-10-17 04:45:18 -04:00
ISC_TEST_ENTRY(duration)
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 04:56:42 -04:00
ISC_TEST_LIST_END
Extend ttlval to accept ISO 8601 durations The ttlval configuration types are replaced by duration configuration types. The duration is an ISO 8601 duration that is going to be used for DNSSEC key timings such as key lifetimes, signature resign intervals and refresh periods, etc. But it is also still allowed to use the BIND ttlval ways of configuring intervals (number plus optional unit). A duration is stored as an array of 7 different time parts. A duration can either be expressed in weeks, or in a combination of the other datetime indicators. Add several unit tests to ensure the correct value is parsed given different string values.
2019-09-02 09:46:28 -04:00
Replace isc_log_create/destroy with isc_logconfig_get() Add isc_logconfig_get() function to get the current logconfig and use the getter to replace most of the little dancing around setting up logging in the tools. Thus: isc_log_create(mctx, &lctx, &logconfig); isc_log_setcontext(lctx); dns_log_setcontext(lctx); ... ...use lcfg... ... isc_log_destroy(); is now only: logconfig = isc_logconfig_get(lctx); ...use lcfg... For thread-safety, isc_logconfig_get() should be surrounded by RCU read lock, but since we never use isc_logconfig_get() in threaded context, the only place where it is actually used (but not really needed) is named_log_init().
2024-08-13 09:52:51 -04:00
ISC_TEST_MAIN_CUSTOM(setup_test_group, NULL)
Reference in a new issue Copy permalink