mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 10:10:06 +00:00
Code Issues Releases Wiki Activity
bind/lib/ns/tests/plugin_test.c

166 lines
4.1 KiB
C
Raw Normal View History

Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
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 08:37:05 +02:00
* SPDX-License-Identifier: MPL-2.0
*
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01: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
update all copyright headers to eliminate the typo
2020-09-14 16:20:40 -07:00
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
Unify header ordering in unit tests Make sure all unit tests include headers in a similar order: 1. Three headers which must be included before <cmocka.h>. 2. System headers. 3. UNIT_TESTING definition, followed by the <cmocka.h> header. 4. libisc headers. 5. Headers from other BIND libraries. 6. Local headers. Also make sure header file names are sorted alphabetically within each block of #include directives.
2019-07-30 21:08:40 +02:00
#include <limits.h>
Include <sched.h> where necessary for musl libc All unit tests define the UNIT_TESTING macro, which causes <cmocka.h> to replace malloc(), calloc(), realloc(), and free() with its own functions tracking memory allocations. In order for this not to break compilation, the system header declaring the prototypes for these standard functions must be included before <cmocka.h>. Normally, these prototypes are only present in <stdlib.h>, so we make sure it is included before <cmocka.h>. However, musl libc also defines the prototypes for calloc() and free() in <sched.h>, which is included by <pthread.h>, which is included e.g. by <isc/mutex.h>. Thus, unit tests including "dnstest.h" (which includes <isc/mem.h>, which includes <isc/mutex.h>) after <cmocka.h> will not compile with musl libc as for these programs, <sched.h> will be included after <cmocka.h>. Always including <cmocka.h> after all other header files is not a feasible solution as that causes the mock assertion macros defined in <isc/util.h> to mangle the contents of <cmocka.h>, thus breaking compilation. We cannot really use the __noreturn__ or analyzer_noreturn attributes with cmocka assertion functions because they do return if the tested condition is true. The problem is that what BIND unit tests do is incompatible with Clang Static Analyzer's assumptions: since we use cmocka, our custom assertion handlers are present in a shared library (i.e. it is the cmocka library that checks the assertion condition, not a macro in unit test code). Redefining cmocka's assertion macros in <isc/util.h> is an ugly hack to overcome that problem - unfortunately, this is the only way we can think of to make Clang Static Analyzer properly process unit test code. Giving up on Clang Static Analyzer being able to properly process unit test code is not a satisfactory solution. Undefining _GNU_SOURCE for unit test code could work around the problem (musl libc's <sched.h> only defines the prototypes for calloc() and free() when _GNU_SOURCE is defined), but doing that could introduce discrepancies for unit tests including entire *.c files, so it is also not a good solution. All in all, including <sched.h> before <cmocka.h> for all affected unit tests seems to be the most benign way of working around this musl libc quirk. While quite an ugly solution, it achieves our goals here, which are to keep the benefit of proper static analysis of unit test code and to fix compilation against musl libc.
2019-07-30 21:08:40 +02:00
#include <sched.h> /* IWYU pragma: keep */
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#include <setjmp.h>
#include <stdarg.h>
Unify header ordering in unit tests Make sure all unit tests include headers in a similar order: 1. Three headers which must be included before <cmocka.h>. 2. System headers. 3. UNIT_TESTING definition, followed by the <cmocka.h> header. 4. libisc headers. 5. Headers from other BIND libraries. 6. Local headers. Also make sure header file names are sorted alphabetically within each block of #include directives.
2019-07-30 21:08:40 +02:00
#include <stdbool.h>
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#include <stddef.h>
Include <sched.h> where necessary for musl libc All unit tests define the UNIT_TESTING macro, which causes <cmocka.h> to replace malloc(), calloc(), realloc(), and free() with its own functions tracking memory allocations. In order for this not to break compilation, the system header declaring the prototypes for these standard functions must be included before <cmocka.h>. Normally, these prototypes are only present in <stdlib.h>, so we make sure it is included before <cmocka.h>. However, musl libc also defines the prototypes for calloc() and free() in <sched.h>, which is included by <pthread.h>, which is included e.g. by <isc/mutex.h>. Thus, unit tests including "dnstest.h" (which includes <isc/mem.h>, which includes <isc/mutex.h>) after <cmocka.h> will not compile with musl libc as for these programs, <sched.h> will be included after <cmocka.h>. Always including <cmocka.h> after all other header files is not a feasible solution as that causes the mock assertion macros defined in <isc/util.h> to mangle the contents of <cmocka.h>, thus breaking compilation. We cannot really use the __noreturn__ or analyzer_noreturn attributes with cmocka assertion functions because they do return if the tested condition is true. The problem is that what BIND unit tests do is incompatible with Clang Static Analyzer's assumptions: since we use cmocka, our custom assertion handlers are present in a shared library (i.e. it is the cmocka library that checks the assertion condition, not a macro in unit test code). Redefining cmocka's assertion macros in <isc/util.h> is an ugly hack to overcome that problem - unfortunately, this is the only way we can think of to make Clang Static Analyzer properly process unit test code. Giving up on Clang Static Analyzer being able to properly process unit test code is not a satisfactory solution. Undefining _GNU_SOURCE for unit test code could work around the problem (musl libc's <sched.h> only defines the prototypes for calloc() and free() when _GNU_SOURCE is defined), but doing that could introduce discrepancies for unit tests including entire *.c files, so it is also not a good solution. All in all, including <sched.h> before <cmocka.h> for all affected unit tests seems to be the most benign way of working around this musl libc quirk. While quite an ugly solution, it achieves our goals here, which are to keep the benefit of proper static analysis of unit test code and to fix compilation against musl libc.
2019-07-30 21:08:40 +02:00
#include <stdlib.h>
Unify header ordering in unit tests Make sure all unit tests include headers in a similar order: 1. Three headers which must be included before <cmocka.h>. 2. System headers. 3. UNIT_TESTING definition, followed by the <cmocka.h> header. 4. libisc headers. 5. Headers from other BIND libraries. 6. Local headers. Also make sure header file names are sorted alphabetically within each block of #include directives.
2019-07-30 21:08:40 +02:00
#include <string.h>
Include <sched.h> where necessary for musl libc All unit tests define the UNIT_TESTING macro, which causes <cmocka.h> to replace malloc(), calloc(), realloc(), and free() with its own functions tracking memory allocations. In order for this not to break compilation, the system header declaring the prototypes for these standard functions must be included before <cmocka.h>. Normally, these prototypes are only present in <stdlib.h>, so we make sure it is included before <cmocka.h>. However, musl libc also defines the prototypes for calloc() and free() in <sched.h>, which is included by <pthread.h>, which is included e.g. by <isc/mutex.h>. Thus, unit tests including "dnstest.h" (which includes <isc/mem.h>, which includes <isc/mutex.h>) after <cmocka.h> will not compile with musl libc as for these programs, <sched.h> will be included after <cmocka.h>. Always including <cmocka.h> after all other header files is not a feasible solution as that causes the mock assertion macros defined in <isc/util.h> to mangle the contents of <cmocka.h>, thus breaking compilation. We cannot really use the __noreturn__ or analyzer_noreturn attributes with cmocka assertion functions because they do return if the tested condition is true. The problem is that what BIND unit tests do is incompatible with Clang Static Analyzer's assumptions: since we use cmocka, our custom assertion handlers are present in a shared library (i.e. it is the cmocka library that checks the assertion condition, not a macro in unit test code). Redefining cmocka's assertion macros in <isc/util.h> is an ugly hack to overcome that problem - unfortunately, this is the only way we can think of to make Clang Static Analyzer properly process unit test code. Giving up on Clang Static Analyzer being able to properly process unit test code is not a satisfactory solution. Undefining _GNU_SOURCE for unit test code could work around the problem (musl libc's <sched.h> only defines the prototypes for calloc() and free() when _GNU_SOURCE is defined), but doing that could introduce discrepancies for unit tests including entire *.c files, so it is also not a good solution. All in all, including <sched.h> before <cmocka.h> for all affected unit tests seems to be the most benign way of working around this musl libc quirk. While quite an ugly solution, it achieves our goals here, which are to keep the benefit of proper static analysis of unit test code and to fix compilation against musl libc.
2019-07-30 21:08:40 +02:00
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
#define UNIT_TESTING
#include <cmocka.h>
Complete rewrite the BIND 9 build system The rewrite of BIND 9 build system is a large work and cannot be reasonable split into separate merge requests. Addition of the automake has a positive effect on the readability and maintainability of the build system as it is more declarative, it allows conditional and we are able to drop all of the custom make code that BIND 9 developed over the years to overcome the deficiencies of autoconf + custom Makefile.in files. This squashed commit contains following changes: - conversion (or rather fresh rewrite) of all Makefile.in files to Makefile.am by using automake - the libtool is now properly integrated with automake (the way we used it was rather hackish as the only official way how to use libtool is via automake - the dynamic module loading was rewritten from a custom patchwork to libtool's libltdl (which includes the patchwork to support module loading on different systems internally) - conversion of the unit test executor from kyua to automake parallel driver - conversion of the system test executor from custom make/shell to automake parallel driver - The GSSAPI has been refactored, the custom SPNEGO on the basis that all major KRB5/GSSAPI (mit-krb5, heimdal and Windows) implementations support SPNEGO mechanism. - The various defunct tests from bin/tests have been removed: bin/tests/optional and bin/tests/pkcs11 - The text files generated from the MD files have been removed, the MarkDown has been designed to be readable by both humans and computers - The xsl header is now generated by a simple sed command instead of perl helper - The <irs/platform.h> header has been removed - cleanups of configure.ac script to make it more simpler, addition of multiple macros (there's still work to be done though) - the tarball can now be prepared with `make dist` - the system tests are partially able to run in oot build Here's a list of unfinished work that needs to be completed in subsequent merge requests: - `make distcheck` doesn't yet work (because of system tests oot run is not yet finished) - documentation is not yet built, there's a different merge request with docbook to sphinx-build rst conversion that needs to be rebased and adapted on top of the automake - msvc build is non functional yet and we need to decide whether we will just cross-compile bind9 using mingw-w64 or fix the msvc build - contributed dlz modules are not included neither in the autoconf nor automake
2018-08-07 16:46:53 +02:00
#include <isc/attributes.h>
Move NAME_MAX and PATH_MAX from isc/platform.h to isc/dir.h The last remaining defines needed for platforms without NAME_MAX and PATH_MAX (I'm looking at you, GNU Hurd) were moved to isc/dir.h where it's prevalently used.
2021-06-10 08:14:57 +02:00
#include <isc/dir.h>
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
#include <isc/mem.h>
#include <isc/result.h>
#include <isc/types.h>
#include <isc/util.h>
Replace ISC_NORETURN with C11's noreturn C11 has builtin support for _Noreturn function specifier with convenience noreturn macro defined in <stdnoreturn.h> header. Replace ISC_NORETURN macro by C11 noreturn with fallback to __attribute__((noreturn)) if the C11 support is not complete.
2021-10-11 12:57:27 +02:00
noreturn void
Complete rewrite the BIND 9 build system The rewrite of BIND 9 build system is a large work and cannot be reasonable split into separate merge requests. Addition of the automake has a positive effect on the readability and maintainability of the build system as it is more declarative, it allows conditional and we are able to drop all of the custom make code that BIND 9 developed over the years to overcome the deficiencies of autoconf + custom Makefile.in files. This squashed commit contains following changes: - conversion (or rather fresh rewrite) of all Makefile.in files to Makefile.am by using automake - the libtool is now properly integrated with automake (the way we used it was rather hackish as the only official way how to use libtool is via automake - the dynamic module loading was rewritten from a custom patchwork to libtool's libltdl (which includes the patchwork to support module loading on different systems internally) - conversion of the unit test executor from kyua to automake parallel driver - conversion of the system test executor from custom make/shell to automake parallel driver - The GSSAPI has been refactored, the custom SPNEGO on the basis that all major KRB5/GSSAPI (mit-krb5, heimdal and Windows) implementations support SPNEGO mechanism. - The various defunct tests from bin/tests have been removed: bin/tests/optional and bin/tests/pkcs11 - The text files generated from the MD files have been removed, the MarkDown has been designed to be readable by both humans and computers - The xsl header is now generated by a simple sed command instead of perl helper - The <irs/platform.h> header has been removed - cleanups of configure.ac script to make it more simpler, addition of multiple macros (there's still work to be done though) - the tarball can now be prepared with `make dist` - the system tests are partially able to run in oot build Here's a list of unfinished work that needs to be completed in subsequent merge requests: - `make distcheck` doesn't yet work (because of system tests oot run is not yet finished) - documentation is not yet built, there's a different merge request with docbook to sphinx-build rst conversion that needs to be rebased and adapted on top of the automake - msvc build is non functional yet and we need to decide whether we will just cross-compile bind9 using mingw-w64 or fix the msvc build - contributed dlz modules are not included neither in the autoconf nor automake
2018-08-07 16:46:53 +02:00
_fail(const char *const file, const int line);
add noreturn attribute
2019-03-07 16:45:04 +11:00
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
#include <ns/hooks.h>
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 10:56:42 +02:00
#include <ns/test.h>
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
/*%
* Structure containing parameters for run_full_path_test().
*/
typedef struct {
apply the modified style
2020-02-13 14:44:37 -08:00
const ns_test_id_t id; /* libns test identifier */
const char *input; /* source string - plugin name or path
* */
size_t output_size; /* size of target char array to
* allocate */
isc_result_t result; /* expected return value */
const char *output; /* expected output string */
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
} ns_plugin_expandpath_test_params_t;
/*%
* Perform a single ns_plugin_expandpath() check using given parameters.
*/
static void
apply the modified style
2020-02-13 14:44:37 -08:00
run_full_path_test(const ns_plugin_expandpath_test_params_t *test,
void **state) {
char **target = (char **)state;
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
isc_result_t result;
REQUIRE(test != NULL);
REQUIRE(test->id.description != NULL);
REQUIRE(test->input != NULL);
REQUIRE(test->result != ISC_R_SUCCESS || test->output != NULL);
/*
* Prepare a target buffer of given size. Store it in 'state' so that
* it can get cleaned up by _teardown() if the test fails.
*/
*target = isc_mem_allocate(mctx, test->output_size);
/*
* Call ns_plugin_expandpath().
*/
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
result = ns_plugin_expandpath(test->input, *target, test->output_size);
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
/*
* Check return value.
*/
if (result != test->result) {
fail_msg("# test \"%s\" on line %d: "
"expected result %d (%s), got %d (%s)",
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
test->id.description, test->id.lineno, test->result,
isc_result_totext(test->result), result,
isc_result_totext(result));
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
}
/*
* Check output string if return value indicates success.
*/
if (result == ISC_R_SUCCESS && strcmp(*target, test->output) != 0) {
fail_msg("# test \"%s\" on line %d: "
"expected output \"%s\", got \"%s\"",
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
test->id.description, test->id.lineno, test->output,
*target);
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
}
isc_mem_free(mctx, *target);
}
/* test ns_plugin_expandpath() */
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 10:56:42 +02:00
ISC_RUN_TEST_IMPL(ns_plugin_expandpath) {
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
size_t i;
const ns_plugin_expandpath_test_params_t tests[] = {
{
NS_TEST_ID("correct use with an absolute path"),
.input = "/usr/lib/named/foo.so",
.output_size = PATH_MAX,
.result = ISC_R_SUCCESS,
.output = "/usr/lib/named/foo.so",
},
{
NS_TEST_ID("correct use with a relative path"),
.input = "../../foo.so",
.output_size = PATH_MAX,
.result = ISC_R_SUCCESS,
.output = "../../foo.so",
},
{
NS_TEST_ID("correct use with a filename"),
.input = "foo.so",
.output_size = PATH_MAX,
.result = ISC_R_SUCCESS,
.output = NAMED_PLUGINDIR "/foo.so",
},
{
NS_TEST_ID("no space at all in target buffer"),
.input = "/usr/lib/named/foo.so",
.output_size = 0,
.result = ISC_R_NOSPACE,
},
{
NS_TEST_ID("target buffer too small to fit input"),
.input = "/usr/lib/named/foo.so",
.output_size = 1,
.result = ISC_R_NOSPACE,
},
{
NS_TEST_ID("target buffer too small to fit NULL byte"),
.input = "/foo.so",
.output_size = 7,
.result = ISC_R_NOSPACE,
},
{
NS_TEST_ID("target buffer too small to fit full path"),
.input = "foo.so",
.output_size = 7,
.result = ISC_R_NOSPACE,
},
};
for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
run_full_path_test(&tests[i], state);
}
}
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 10:56:42 +02:00
ISC_TEST_LIST_START
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01: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 10:56:42 +02:00
ISC_TEST_ENTRY_CUSTOM(ns_plugin_expandpath, setup_managers, teardown_managers)
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01: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 10:56:42 +02:00
ISC_TEST_LIST_END
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01: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 10:56:42 +02:00
ISC_TEST_MAIN
Reference in New Issue Copy Permalink