-set(THREADS_PREFER_PTHREAD_FLAG ON)
# globals
-include(CTest)
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+ include(CTest)
+endif()
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
if(BUILD_TESTING)
set(MEMCACHED_BINARY "/usr/bin/memcached"
CACHE FILEPATH "memcached binary")
+ set(CMAKE_CTEST_ARGUMENTS "--output-on-failure;-j2;--repeat;until-pass:2"
+ ) # available since CMake 3.17
endif()
if(BUILD_DOCS)
--- /dev/null
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+Catch
+-----
+
+This module defines a function to help use the Catch test framework.
+
+The :command:`catch_discover_tests` discovers tests by asking the compiled test
+executable to enumerate its tests. This does not require CMake to be re-run
+when tests change. However, it may not work in a cross-compiling environment,
+and setting test properties is less convenient.
+
+This command is intended to replace use of :command:`add_test` to register
+tests, and will create a separate CTest test for each Catch test case. Note
+that this is in some cases less efficient, as common set-up and tear-down logic
+cannot be shared by multiple test cases executing in the same instance.
+However, it provides more fine-grained pass/fail information to CTest, which is
+usually considered as more beneficial. By default, the CTest test name is the
+same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
+
+.. command:: catch_discover_tests
+
+ Automatically add tests with CTest by querying the compiled test executable
+ for available tests::
+
+ catch_discover_tests(target
+ [TEST_SPEC arg1...]
+ [EXTRA_ARGS arg1...]
+ [WORKING_DIRECTORY dir]
+ [TEST_PREFIX prefix]
+ [TEST_SUFFIX suffix]
+ [PROPERTIES name1 value1...]
+ [TEST_LIST var]
+ )
+
+ ``catch_discover_tests`` sets up a post-build command on the test executable
+ that generates the list of tests by parsing the output from running the test
+ with the ``--list-test-names-only`` argument. This ensures that the full
+ list of tests is obtained. Since test discovery occurs at build time, it is
+ not necessary to re-run CMake when the list of tests changes.
+ However, it requires that :prop_tgt:`CROSSCOMPILING_EMULATOR` is properly set
+ in order to function in a cross-compiling environment.
+
+ Additionally, setting properties on tests is somewhat less convenient, since
+ the tests are not available at CMake time. Additional test properties may be
+ assigned to the set of tests as a whole using the ``PROPERTIES`` option. If
+ more fine-grained test control is needed, custom content may be provided
+ through an external CTest script using the :prop_dir:`TEST_INCLUDE_FILES`
+ directory property. The set of discovered tests is made accessible to such a
+ script via the ``<target>_TESTS`` variable.
+
+ The options are:
+
+ ``target``
+ Specifies the Catch executable, which must be a known CMake executable
+ target. CMake will substitute the location of the built executable when
+ running the test.
+
+ ``TEST_SPEC arg1...``
+ Specifies test cases, wildcarded test cases, tags and tag expressions to
+ pass to the Catch executable with the ``--list-test-names-only`` argument.
+
+ ``EXTRA_ARGS arg1...``
+ Any extra arguments to pass on the command line to each test case.
+
+ ``WORKING_DIRECTORY dir``
+ Specifies the directory in which to run the discovered test cases. If this
+ option is not provided, the current binary directory is used.
+
+ ``TEST_PREFIX prefix``
+ Specifies a ``prefix`` to be prepended to the name of each discovered test
+ case. This can be useful when the same test executable is being used in
+ multiple calls to ``catch_discover_tests()`` but with different
+ ``TEST_SPEC`` or ``EXTRA_ARGS``.
+
+ ``TEST_SUFFIX suffix``
+ Similar to ``TEST_PREFIX`` except the ``suffix`` is appended to the name of
+ every discovered test case. Both ``TEST_PREFIX`` and ``TEST_SUFFIX`` may
+ be specified.
+
+ ``PROPERTIES name1 value1...``
+ Specifies additional properties to be set on all tests discovered by this
+ invocation of ``catch_discover_tests``.
+
+ ``TEST_LIST var``
+ Make the list of tests available in the variable ``var``, rather than the
+ default ``<target>_TESTS``. This can be useful when the same test
+ executable is being used in multiple calls to ``catch_discover_tests()``.
+ Note that this variable is only available in CTest.
+
+#]=======================================================================]
+
+#------------------------------------------------------------------------------
+function(catch_discover_tests TARGET)
+ cmake_parse_arguments(
+ ""
+ ""
+ "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST"
+ "TEST_SPEC;EXTRA_ARGS;PROPERTIES"
+ ${ARGN}
+ )
+
+ if(NOT _WORKING_DIRECTORY)
+ set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+ endif()
+ if(NOT _TEST_LIST)
+ set(_TEST_LIST ${TARGET}_TESTS)
+ endif()
+
+ ## Generate a unique name based on the extra arguments
+ string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS}")
+ string(SUBSTRING ${args_hash} 0 7 args_hash)
+
+ # Define rule to generate test list for aforementioned test executable
+ set(ctest_include_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_include-${args_hash}.cmake")
+ set(ctest_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_tests-${args_hash}.cmake")
+ get_property(crosscompiling_emulator
+ TARGET ${TARGET}
+ PROPERTY CROSSCOMPILING_EMULATOR
+ )
+ add_custom_command(
+ TARGET ${TARGET} POST_BUILD
+ BYPRODUCTS "${ctest_tests_file}"
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_TARGET=${TARGET}"
+ -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
+ -D "TEST_EXECUTOR=${crosscompiling_emulator}"
+ -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
+ -D "TEST_SPEC=${_TEST_SPEC}"
+ -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
+ -D "TEST_PROPERTIES=${_PROPERTIES}"
+ -D "TEST_PREFIX=${_TEST_PREFIX}"
+ -D "TEST_SUFFIX=${_TEST_SUFFIX}"
+ -D "TEST_LIST=${_TEST_LIST}"
+ -D "CTEST_FILE=${ctest_tests_file}"
+ -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
+ VERBATIM
+ )
+
+ file(WRITE "${ctest_include_file}"
+ "if(EXISTS \"${ctest_tests_file}\")\n"
+ " include(\"${ctest_tests_file}\")\n"
+ "else()\n"
+ " add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
+ "endif()\n"
+ )
+
+ if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+ # Add discovered tests to directory TEST_INCLUDE_FILES
+ set_property(DIRECTORY
+ APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
+ )
+ else()
+ # Add discovered tests as directory TEST_INCLUDE_FILE if possible
+ get_property(test_include_file_set DIRECTORY PROPERTY TEST_INCLUDE_FILE SET)
+ if (NOT ${test_include_file_set})
+ set_property(DIRECTORY
+ PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
+ )
+ else()
+ message(FATAL_ERROR
+ "Cannot set more than one TEST_INCLUDE_FILE"
+ )
+ endif()
+ endif()
+
+endfunction()
+
+###############################################################################
+
+set(_CATCH_DISCOVER_TESTS_SCRIPT
+ ${CMAKE_CURRENT_LIST_DIR}/CatchAddTests.cmake
+)
--- /dev/null
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+set(prefix "${TEST_PREFIX}")
+set(suffix "${TEST_SUFFIX}")
+set(spec ${TEST_SPEC})
+set(extra_args ${TEST_EXTRA_ARGS})
+set(properties ${TEST_PROPERTIES})
+set(script)
+set(suite)
+set(tests)
+
+function(add_command NAME)
+ set(_args "")
+ foreach(_arg ${ARGN})
+ if(_arg MATCHES "[^-./:a-zA-Z0-9_]")
+ set(_args "${_args} [==[${_arg}]==]") # form a bracket_argument
+ else()
+ set(_args "${_args} ${_arg}")
+ endif()
+ endforeach()
+ set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
+endfunction()
+
+# Run test executable to get list of available tests
+if(NOT EXISTS "${TEST_EXECUTABLE}")
+ message(FATAL_ERROR
+ "Specified test executable '${TEST_EXECUTABLE}' does not exist"
+ )
+endif()
+execute_process(
+ COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-test-names-only
+ OUTPUT_VARIABLE output
+ RESULT_VARIABLE result
+)
+# Catch --list-test-names-only reports the number of tests, so 0 is... surprising
+if(${result} EQUAL 0)
+ message(WARNING
+ "Test executable '${TEST_EXECUTABLE}' contains no tests!\n"
+ )
+elseif(${result} LESS 0)
+ message(FATAL_ERROR
+ "Error running test executable '${TEST_EXECUTABLE}':\n"
+ " Result: ${result}\n"
+ " Output: ${output}\n"
+ )
+endif()
+
+string(REPLACE "\n" ";" output "${output}")
+
+# Parse output
+foreach(line ${output})
+ set(test ${line})
+ # Escape characters in test case names that would be parsed by Catch2
+ set(test_name ${test})
+ foreach(char , [ ])
+ string(REPLACE ${char} "\\${char}" test_name ${test_name})
+ endforeach(char)
+ # ...and add to script
+ add_command(add_test
+ "${prefix}${test}${suffix}"
+ ${TEST_EXECUTOR}
+ "${TEST_EXECUTABLE}"
+ "${test_name}"
+ ${extra_args}
+ )
+ add_command(set_tests_properties
+ "${prefix}${test}${suffix}"
+ PROPERTIES
+ WORKING_DIRECTORY "${TEST_WORKING_DIR}"
+ ${properties}
+ )
+ list(APPEND tests "${prefix}${test}${suffix}")
+endforeach()
+
+# Create a list of all discovered tests, which users may use to e.g. set
+# properties on the tests
+add_command(set ${TEST_LIST} ${tests})
+
+# Write CTest script
+file(WRITE "${CTEST_FILE}" "${script}")
-if(NOT BUILD_TESTING)
+if(NOT BUILD_TESTING OR NOT CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
return()
endif()
+include(CMake/Catch.cmake)
+
file(GLOB_RECURSE TESTING_SRC RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
set(TESTING_ROOT ${CMAKE_CURRENT_BINARY_DIR})
set_source_files_properties(main.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
target_link_libraries(runtests PRIVATE libhashkit libmemcached libmemcachedutil)
add_dependencies(runtests ${CLIENTS})
-macro(add_test TEST_CASE)
- _add_test(${TEST_CASE} runtests ${TEST_CASE})
-endmacro()
-
-add_test("lib/Server")
-add_test("lib/Cluster")
-
-add_test("hashkit")
-
-add_test("memcached_append")
-add_test("memcached_basic")
-add_test("memcached_callbacks")
-add_test("memcached_cas")
-add_test("memcached_dump")
-add_test("memcached_encoding_key")
-add_test("memcached_exist")
-add_test("memcached_generate_hash")
-add_test("memcached_haldenbrand_nblock_tcp_ndelay")
-add_test("memcached_inc_dec")
-add_test("memcached_ketama_compat")
-add_test("memcached_noreply")
-add_test("memcached_prepend")
-add_test("memcached_regression_binary_block_add")
-add_test("memcached_servers")
-add_test("memcached_simple")
-add_test("memcached_util")
-
-add_test("memcat")
-add_test("memcp")
-add_test("memdump")
-add_test("memerror")
-add_test("memexist")
-add_test("memflush")
+catch_discover_tests(runtests
+ TEST_SPEC "lib*")
+catch_discover_tests(runtests
+ TEST_SPEC "hashkit*")
+catch_discover_tests(runtests
+ TEST_SPEC "memcached*")
+catch_discover_tests(runtests
+ TEST_SPEC "bin/*")
#pragma once
#cmakedefine TESTING_ROOT "@TESTING_ROOT@"
+#cmakedefine MEMCACHED_BINARY getenv_else("MEMCACHED_BINARY", "@MEMCACHED_BINARY@")
MemcachedCluster::MemcachedCluster()
: cluster{Server{
- getenv_else("MEMCACHED_BINARY", "memcached"),
+ MEMCACHED_BINARY,
{random_socket_or_port_arg()}
}}
{
MemcachedCluster MemcachedCluster::network() {
return MemcachedCluster{Cluster{Server{
- getenv_else("MEMCACHED_BINARY", "memcached"),
+ MEMCACHED_BINARY,
{"-p", random_socket_or_port_string}
}}};
}
MemcachedCluster MemcachedCluster::socket() {
return MemcachedCluster{Cluster{Server{
- getenv_else("MEMCACHED_BINARY", "memcached"),
+ MEMCACHED_BINARY,
{"-s", random_socket_or_port_string}
}}};
}
using Catch::Matchers::Contains;
-TEST_CASE("memcat") {
+TEST_CASE("bin/memcat") {
Shell sh{string{TESTING_ROOT "/../src/bin"}};
SECTION("no servers provided") {
}
SECTION("with server") {
- Server server{"memcached", {"-p", random_port_string}};
+ Server server{MEMCACHED_BINARY, {"-p", random_port_string}};
MemcachedPtr memc;
LoneReturnMatcher test{*memc};
using Catch::Matchers::Contains;
-TEST_CASE("memcp") {
+TEST_CASE("bin/memcp") {
Shell sh{string{TESTING_ROOT "/../src/bin"}};
SECTION("no servers provided") {
}
SECTION("with server") {
- Server server{"memcached", {"-p", random_port_string}};
+ Server server{MEMCACHED_BINARY, {"-p", random_port_string}};
MemcachedPtr memc;
LoneReturnMatcher test{*memc};
SECTION("connection failure") {
server.signal(SIGKILL);
- server.tryWait();
+ server.wait();
Tempfile temp;
using Catch::Matchers::Contains;
-TEST_CASE("memdump") {
+TEST_CASE("bin/memdump") {
Shell sh{string{TESTING_ROOT "/../src/bin"}};
SECTION("no servers provided") {
}
SECTION("with server") {
- Server server{"memcached", {"-p", random_port_string}};
+ Server server{MEMCACHED_BINARY, {"-p", random_port_string}};
MemcachedPtr memc;
LoneReturnMatcher test{*memc};
SECTION("connection failure") {
server.signal(SIGKILL);
- server.tryWait();
+ server.wait();
string output;
REQUIRE_FALSE(sh.run(comm + "-v", output));
using Catch::Matchers::Contains;
-TEST_CASE("memerror") {
+TEST_CASE("bin/memerror") {
Shell sh{string{TESTING_ROOT "/../src/bin"}};
SECTION("--help") {
using Catch::Matchers::Contains;
-TEST_CASE("memexist") {
+TEST_CASE("bin/memexist") {
Shell sh{string{TESTING_ROOT "/../src/bin"}};
SECTION("no servers provided") {
}
SECTION("with server") {
- Server server{"memcached", {"-p", random_port_string}};
+ Server server{MEMCACHED_BINARY, {"-p", random_port_string}};
MemcachedPtr memc;
LoneReturnMatcher test{*memc};
using Catch::Matchers::Contains;
-TEST_CASE("memflush") {
+TEST_CASE("bin/memflush") {
Shell sh{string{TESTING_ROOT "/../src/bin"}};
SECTION("no servers provided") {
}
SECTION("with server") {
- Server server{"memcached", {"-p", random_port_string}};
+ Server server{MEMCACHED_BINARY, {"-p", random_port_string}};
MemcachedPtr memc;
LoneReturnMatcher test{*memc};
SECTION("connection failure") {
server.signal(SIGKILL);
- server.tryWait();
+ server.wait();
string output;
REQUIRE_FALSE(sh.run(comm, output));
#include "testing/lib/Server.hpp"
TEST_CASE("lib/Server") {
- Server server{"memcached"};
+ Server server{MEMCACHED_BINARY};
SECTION("starts and listens") {
}
TEST_CASE("lib/Cluster") {
- Cluster cluster{Server{"memcached", {
+ Cluster cluster{Server{MEMCACHED_BINARY, {
random_socket_or_port_arg(),
}}};
projects / m6w6 / libmemcached / commitdiff
