diff --git a/.gdbinit b/.gdbinit new file mode 100644 index 00000000..999e2fce --- /dev/null +++ b/.gdbinit @@ -0,0 +1,2 @@ +# Load pretty printers +source tools/gdb_pretty_printers/autoload.py \ No newline at end of file diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml new file mode 100644 index 00000000..9b1a2060 --- /dev/null +++ b/.github/workflows/cifuzz.yml @@ -0,0 +1,26 @@ +name: CIFuzz +on: [pull_request] +jobs: + Fuzzing: + runs-on: ubuntu-latest + steps: + - name: Build Fuzzers + id: build + uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master + with: + oss-fuzz-project-name: 'immer' + dry-run: false + language: c++ + - name: Run Fuzzers + uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master + with: + oss-fuzz-project-name: 'immer' + fuzz-seconds: 300 + dry-run: false + language: c++ + - name: Upload Crash + uses: actions/upload-artifact@v3 + if: failure() && steps.build.outcome == 'success' + with: + name: artifacts + path: ./out/artifacts diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 07b7d241..253215f1 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -7,25 +7,33 @@ jobs: - uses: actions/checkout@v2 with: fetch-depth: 0 # needed for fetchGit in default.nix - - uses: cachix/install-nix-action@v12 + - uses: cachix/install-nix-action@v20 with: nix_path: nixpkgs=channel:nixos-unstable - - uses: cachix/cachix-action@v8 + - uses: cachix/cachix-action@v12 with: name: arximboldi signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}' - run: nix-build + build-spm: + runs-on: macos-latest + steps: + - uses: actions/checkout@v2 + with: + submodules: true + - run: swift build + docs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: submodules: true - - uses: cachix/install-nix-action@v12 + - uses: cachix/install-nix-action@v20 with: nix_path: nixpkgs=channel:nixos-unstable - - uses: cachix/cachix-action@v8 + - uses: cachix/cachix-action@v12 with: name: arximboldi signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}' @@ -33,12 +41,12 @@ jobs: - run: nix-shell --run "cd build && cmake .." - run: nix-shell --run "cd build && make docs" - uses: shimataro/ssh-key-action@v2 - if: github.ref == 'refs/heads/master' + if: github.ref == 'refs/heads/master' && github.repository_owner == 'arximboldi' with: key: ${{ secrets.SINUSOIDES_SSH_KEY }} known_hosts: ${{ secrets.SINUSOIDES_KNOWN_HOSTS }} - run: nix-shell --run "cd build && make upload-docs" - if: github.ref == 'refs/heads/master' + if: github.ref == 'refs/heads/master' && github.repository_owner == 'arximboldi' check: strategy: @@ -61,11 +69,18 @@ jobs: toolchain: llvm-9 std: 17 opts: ['fuzzers'] + # std 20 + - type: Debug + toolchain: gnu-11 + std: 20 + - type: Debug + toolchain: llvm-13 + std: 20 # sanitizers - type: Debug toolchain: llvm-8 std: 14 - opts: ['sanitizer'] + opts: ['sanitize'] # benchmarks - type: Release toolchain: gnu-9 @@ -78,10 +93,10 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - - uses: cachix/install-nix-action@v12 + - uses: cachix/install-nix-action@v20 with: nix_path: nixpkgs=channel:nixos-unstable - - uses: cachix/cachix-action@v8 + - uses: cachix/cachix-action@v12 with: name: arximboldi signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}' @@ -103,11 +118,11 @@ jobs: " - run: nix-shell --argstr toolchain ${{ matrix.toolchain }} --run "cd build && make check -j`nproc`" - run: nix-shell --argstr toolchain ${{ matrix.toolchain }} --run "bash <(curl -s https://codecov.io/bash)" - if: ${{ contains(matrix.opts, 'coverage') }} + if: contains(matrix.opts, 'coverage') - uses: shimataro/ssh-key-action@v2 - if: ${{ contains(matrix.opts, 'benchmark') }} + if: contains(matrix.opts, 'benchmark') && github.repository_owner == 'arximboldi' with: key: ${{ secrets.SINUSOIDES_SSH_KEY }} known_hosts: ${{ secrets.SINUSOIDES_KNOWN_HOSTS }} - run: nix-shell --run "cd build && make upload-benchmark-reports" - if: ${{ contains(matrix.opts, 'benchmark') }} + if: contains(matrix.opts, 'benchmark') && github.repository_owner == 'arximboldi' diff --git a/.gitignore b/.gitignore index 2074141e..46c3c7c2 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,8 @@ __pycache__ tools/clojure/.lein* *.pyc + +/result* + +.build +.swiftpm diff --git a/CMakeLists.txt b/CMakeLists.txt index a6080e1a..091f2b99 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,10 +4,10 @@ cmake_policy(SET CMP0048 NEW) # enable project VERSION cmake_policy(SET CMP0056 NEW) # honor link flags in try_compile() list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") -project(immer VERSION 0.6.2) +project(immer VERSION 0.8.0) if (NOT MSVC) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wno-unused-parameter -Wno-extended-offsetof -Wno-c++17-extensions -Wno-c++1z-extensions -Wno-unknown-warning-option") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wno-unused-parameter -Wno-extended-offsetof -Wno-c++17-extensions -Wno-c++1z-extensions -Wno-unknown-warning-option -Wno-type-limits") endif() set(CMAKE_EXPORT_COMPILE_COMMANDS on) set(CMAKE_CXX_EXTENSIONS off) @@ -76,8 +76,8 @@ find_package(Boost 1.56 COMPONENTS ${immer_boost_components}) find_program(CCACHE ccache) if (CCACHE) message(STATUS "Using ccache: ${CCACHE}") - set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE}) - set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE}) + set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE}) + set(CMAKE_CXX_LINKER_LAUNCHER ${CCACHE}) else() message(STATUS "Could not find ccache") endif() @@ -99,6 +99,14 @@ install(TARGETS immer EXPORT ImmerConfig) install(EXPORT ImmerConfig DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Immer") install(DIRECTORY immer DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") +include(CMakePackageConfigHelpers) +write_basic_package_version_file( + "${CMAKE_CURRENT_BINARY_DIR}/ImmerConfigVersion.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY SameMajorVersion ) + +install(FILES "${CMAKE_CURRENT_BINARY_DIR}/ImmerConfigVersion.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Immer" ) + # development target to be used in tests, examples, benchmarks... immer_canonicalize_cmake_booleans( DISABLE_FREE_LIST @@ -131,6 +139,8 @@ endif() if (immer_BUILD_TESTS) enable_testing() + find_package(Catch2 REQUIRED) + add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} diff --git a/Package.swift b/Package.swift new file mode 100644 index 00000000..af8254e8 --- /dev/null +++ b/Package.swift @@ -0,0 +1,29 @@ +// swift-tools-version:5.5 +// The swift-tools-version declares the minimum version of Swift required to build this package. + +import PackageDescription + +let package = Package( + name: "immer", + products: [ + // Products define the executables and libraries a package produces, and make them visible to other packages. + .library( + name: "immer", + targets: ["immer"]), + ], + dependencies: [ + // Dependencies declare other packages that this package depends on. + // .package(url: /* package url */, from: "1.0.0"), + ], + targets: [ + // Targets are the basic building blocks of a package. A target can define a module or a test suite. + // Targets can depend on other targets in this package, and on products in packages this package depends on. + .target( + name: "immer", + dependencies: [], + path: ".", + sources: ["spm.cpp"], + publicHeadersPath: ".") + ], + cxxLanguageStandard: .cxx14 +) diff --git a/README.rst b/README.rst index abf4dcea..834dbe6a 100644 --- a/README.rst +++ b/README.rst @@ -1,6 +1,6 @@ .. image:: https://github.com/arximboldi/immer/workflows/test/badge.svg :target: https://github.com/arximboldi/immer/actions?query=workflow%3Atest+branch%3Amaster - :alt: Github Actions Badge + :alt: GitHub Actions Badge .. image:: https://codecov.io/gh/arximboldi/immer/branch/master/graph/badge.svg :target: https://codecov.io/gh/arximboldi/immer @@ -13,7 +13,10 @@ .. raw:: html - Logotype + + + Logotype + .. include:introduction/start @@ -74,7 +77,7 @@ Example For a **complete example** check `Ewig, a simple didactic text-editor `_ built with this library. You may also wanna check `Lager, a Redux-like library - `_ for writting interactive + `_ for writing interactive software in C++ using a value-oriented design. diff --git a/benchmark/set/erase.hpp b/benchmark/set/erase.hpp new file mode 100644 index 00000000..a702fd25 --- /dev/null +++ b/benchmark/set/erase.hpp @@ -0,0 +1,85 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +#include "benchmark/config.hpp" + +#include +#include // Phil Nash +#include +#include +#include +#include + +namespace { + +template +auto benchmark_erase_mut_std() +{ + return [](nonius::chronometer meter) { + auto n = meter.param(); + auto g = Generator{}(n); + auto v_ = [&] { + auto v = Set{}; + for (auto i = 0u; i < n; ++i) + v.insert(g[i]); + return v; + }(); + measure(meter, [&] { + auto v = v_; + for (auto i = 0u; i < n; ++i) + v.erase(g[i]); + return v; + }); + }; +} + +template +auto benchmark_erase() +{ + return [](nonius::chronometer meter) { + auto n = meter.param(); + auto g = Generator{}(n); + auto v_ = [&] { + auto v = Set{}.transient(); + for (auto i = 0u; i < n; ++i) + v.insert(g[i]); + return v.persistent(); + }(); + measure(meter, [&] { + auto v = v_; + for (auto i = 0u; i < n; ++i) + v = v.erase(g[i]); + return v; + }); + }; +} + +template +auto benchmark_erase_move() +{ + return [](nonius::chronometer meter) { + auto n = meter.param(); + auto g = Generator{}(n); + auto v_ = [&] { + auto v = Set{}.transient(); + for (auto i = 0u; i < n; ++i) + v.insert(g[i]); + return v.persistent(); + }(); + measure(meter, [&] { + auto v = v_; + for (auto i = 0u; i < n; ++i) + v = std::move(v).erase(g[i]); + return v; + }); + }; +} + +} // namespace diff --git a/benchmark/set/erase.ipp b/benchmark/set/erase.ipp new file mode 100644 index 00000000..54197744 --- /dev/null +++ b/benchmark/set/erase.ipp @@ -0,0 +1,44 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "erase.hpp" + +#ifndef GENERATOR_T +#error "you must define a GENERATOR_T" +#endif + +using generator__ = GENERATOR_T; +using t__ = typename decltype(generator__{}(0))::value_type; + +// clang-format off +NONIUS_BENCHMARK("std::set", benchmark_erase_mut_std>()) +NONIUS_BENCHMARK("std::unordered_set", benchmark_erase_mut_std>()) +NONIUS_BENCHMARK("boost::flat_set", benchmark_erase_mut_std>()) +// Phil Nash's hash_trie seems to not include an erase operation... at least at +// the version that we have included in the nix-shell here... +// NONIUS_BENCHMARK("hamt::hash_trie", benchmark_erase_mut_hash_trie>()) + +NONIUS_BENCHMARK("immer::set/5B", benchmark_erase,std::equal_to,def_memory,5>>()) +NONIUS_BENCHMARK("immer::set/4B", benchmark_erase,std::equal_to,def_memory,4>>()) +#ifndef DISABLE_GC_BENCHMARKS +NONIUS_BENCHMARK("immer::set/GC", benchmark_erase,std::equal_to,gc_memory,5>>()) +#endif +NONIUS_BENCHMARK("immer::set/UN", benchmark_erase,std::equal_to,unsafe_memory,5>>()) + +NONIUS_BENCHMARK("immer::set/move/5B", benchmark_erase_move,std::equal_to,def_memory,5>>()) +NONIUS_BENCHMARK("immer::set/move/4B", benchmark_erase_move,std::equal_to,def_memory,4>>()) +NONIUS_BENCHMARK("immer::set/move/UN", benchmark_erase_move,std::equal_to,unsafe_memory,5>>()) + +NONIUS_BENCHMARK("immer::set/tran/5B", benchmark_erase_mut_std,std::equal_to,def_memory,5>>()) +NONIUS_BENCHMARK("immer::set/tran/4B", benchmark_erase_mut_std,std::equal_to,def_memory,4>>()) +#ifndef DISABLE_GC_BENCHMARKS +NONIUS_BENCHMARK("immer::set/tran/GC", benchmark_erase_mut_std,std::equal_to,gc_memory,5>>()) +#endif +NONIUS_BENCHMARK("immer::set/tran/UN", benchmark_erase_mut_std,std::equal_to,unsafe_memory,5>>()) + +// clang-format on diff --git a/benchmark/set/insert.hpp b/benchmark/set/insert.hpp index be679b4d..8950abfb 100644 --- a/benchmark/set/insert.hpp +++ b/benchmark/set/insert.hpp @@ -10,9 +10,10 @@ #include "benchmark/config.hpp" -#include -#include // Phil Nash #include +#include // Phil Nash +#include +#include #include #include @@ -21,8 +22,7 @@ namespace { template auto benchmark_insert_mut_std() { - return [] (nonius::chronometer meter) - { + return [](nonius::chronometer meter) { auto n = meter.param(); auto g = Generator{}(n); @@ -38,8 +38,7 @@ auto benchmark_insert_mut_std() template auto benchmark_insert() { - return [] (nonius::chronometer meter) - { + return [](nonius::chronometer meter) { auto n = meter.param(); auto g = Generator{}(n); @@ -52,4 +51,20 @@ auto benchmark_insert() }; } +template +auto benchmark_insert_move() +{ + return [](nonius::chronometer meter) { + auto n = meter.param(); + auto g = Generator{}(n); + + measure(meter, [&] { + auto v = Set{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).insert(g[i]); + return v; + }); + }; +} + } // namespace diff --git a/benchmark/set/insert.ipp b/benchmark/set/insert.ipp index 6717ccd5..cc6b648a 100644 --- a/benchmark/set/insert.ipp +++ b/benchmark/set/insert.ipp @@ -13,8 +13,9 @@ #endif using generator__ = GENERATOR_T; -using t__ = typename decltype(generator__{}(0))::value_type; +using t__ = typename decltype(generator__{}(0))::value_type; +// clang-format off NONIUS_BENCHMARK("std::set", benchmark_insert_mut_std>()) NONIUS_BENCHMARK("std::unordered_set", benchmark_insert_mut_std>()) NONIUS_BENCHMARK("boost::flat_set", benchmark_insert_mut_std>()) @@ -26,3 +27,16 @@ NONIUS_BENCHMARK("immer::set/4B", benchmark_insert,std::equal_to,gc_memory,5>>()) #endif NONIUS_BENCHMARK("immer::set/UN", benchmark_insert,std::equal_to,unsafe_memory,5>>()) + +NONIUS_BENCHMARK("immer::set/move/5B", benchmark_insert_move,std::equal_to,def_memory,5>>()) +NONIUS_BENCHMARK("immer::set/move/4B", benchmark_insert_move,std::equal_to,def_memory,4>>()) +NONIUS_BENCHMARK("immer::set/move/UN", benchmark_insert_move,std::equal_to,unsafe_memory,5>>()) + +NONIUS_BENCHMARK("immer::set/tran/5B", benchmark_insert_mut_std,std::equal_to,def_memory,5>>()) +NONIUS_BENCHMARK("immer::set/tran/4B", benchmark_insert_mut_std,std::equal_to,def_memory,4>>()) +#ifndef DISABLE_GC_BENCHMARKS +NONIUS_BENCHMARK("immer::set/tran/GC", benchmark_insert_mut_std,std::equal_to,gc_memory,5>>()) +#endif +NONIUS_BENCHMARK("immer::set/tran/UN", benchmark_insert_mut_std,std::equal_to,unsafe_memory,5>>()) + +// clang-format on diff --git a/benchmark/set/memory/basic-string-long.cpp b/benchmark/set/memory/basic-string-long.cpp new file mode 100644 index 00000000..cd39f7f6 --- /dev/null +++ b/benchmark/set/memory/basic-string-long.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_STRING_LONG 1 + +#include "memory.hpp" + +int main() { return main_basic(); } diff --git a/benchmark/set/memory/basic-string-short.cpp b/benchmark/set/memory/basic-string-short.cpp new file mode 100644 index 00000000..2c4d47cc --- /dev/null +++ b/benchmark/set/memory/basic-string-short.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_STRING_SHORT 1 + +#include "memory.hpp" + +int main() { return main_basic(); } diff --git a/benchmark/set/memory/basic-unsigned.cpp b/benchmark/set/memory/basic-unsigned.cpp new file mode 100644 index 00000000..0b02c404 --- /dev/null +++ b/benchmark/set/memory/basic-unsigned.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_UNSIGNED 1 + +#include "memory.hpp" + +int main() { return main_basic(); } diff --git a/benchmark/set/memory/exp-string-long.cpp b/benchmark/set/memory/exp-string-long.cpp new file mode 100644 index 00000000..866869d9 --- /dev/null +++ b/benchmark/set/memory/exp-string-long.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_STRING_LONG 1 + +#include "memory.hpp" + +int main() { return main_exp(); } diff --git a/benchmark/set/memory/exp-string-short.cpp b/benchmark/set/memory/exp-string-short.cpp new file mode 100644 index 00000000..e198c070 --- /dev/null +++ b/benchmark/set/memory/exp-string-short.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_STRING_SHORT 1 + +#include "memory.hpp" + +int main() { return main_exp(); } diff --git a/benchmark/set/memory/exp-unsigned.cpp b/benchmark/set/memory/exp-unsigned.cpp new file mode 100644 index 00000000..2bed0de5 --- /dev/null +++ b/benchmark/set/memory/exp-unsigned.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_UNSIGNED 1 + +#include "memory.hpp" + +int main() { return main_exp(); } diff --git a/benchmark/set/memory/lin-string-long.cpp b/benchmark/set/memory/lin-string-long.cpp new file mode 100644 index 00000000..ce3d5bd1 --- /dev/null +++ b/benchmark/set/memory/lin-string-long.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_STRING_LONG 1 + +#include "memory.hpp" + +int main() { return main_lin(); } diff --git a/benchmark/set/memory/lin-string-short.cpp b/benchmark/set/memory/lin-string-short.cpp new file mode 100644 index 00000000..f1a610b8 --- /dev/null +++ b/benchmark/set/memory/lin-string-short.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_STRING_SHORT 1 + +#include "memory.hpp" + +int main() { return main_lin(); } diff --git a/benchmark/set/memory/lin-unsigned.cpp b/benchmark/set/memory/lin-unsigned.cpp new file mode 100644 index 00000000..c3e9bad2 --- /dev/null +++ b/benchmark/set/memory/lin-unsigned.cpp @@ -0,0 +1,5 @@ +#define IMMER_BENCHMARK_MEMORY_UNSIGNED 1 + +#include "memory.hpp" + +int main() { return main_lin(); } diff --git a/benchmark/set/memory/memory.hpp b/benchmark/set/memory/memory.hpp new file mode 100644 index 00000000..7b218ba1 --- /dev/null +++ b/benchmark/set/memory/memory.hpp @@ -0,0 +1,451 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#pragma once + +// +// These are some experiments to get insights about memory usage with various +// data-structures and configurations. +// +// The idea is to run this inside valgrind's massif tool and see what comes +// out. The following is the libraries that we do check. +// + +// these are for "exp" tests +#include +#include // Phil Nash +#include +#include +#include +#include + +// these are for "lin" tests, which are map based actually +#include +#include // Phil Nash +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +struct generate_string_short +{ + static constexpr auto char_set = + "_-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + static constexpr auto max_length = 15; + static constexpr auto min_length = 4; + + auto operator()() const + { + auto engine = std::default_random_engine{42}; + auto dist = std::uniform_int_distribution{}; + auto gen = std::bind(dist, engine); + + return [=]() mutable { + auto len = gen() % (max_length - min_length) + min_length; + auto str = std::string(len, ' '); + std::generate_n(str.begin(), len, [&] { + return char_set[gen() % sizeof(char_set)]; + }); + return str; + }; + } +}; + +struct generate_string_long +{ + static constexpr auto char_set = + "_-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + static constexpr auto max_length = 256; + static constexpr auto min_length = 32; + + auto operator()() const + { + auto engine = std::default_random_engine{42}; + auto dist = std::uniform_int_distribution{}; + auto gen = std::bind(dist, engine); + + return [=]() mutable { + auto len = gen() % (max_length - min_length) + min_length; + auto str = std::string(len, ' '); + std::generate_n(str.begin(), len, [&] { + return char_set[gen() % sizeof(char_set)]; + }); + return str; + }; + } +}; + +struct generate_unsigned +{ + auto operator()() const + { + auto engine = std::default_random_engine{42}; + auto dist = std::uniform_int_distribution{}; + auto gen = std::bind(dist, engine); + return gen; + } +}; + +namespace basic_params { +constexpr auto N = 1 << 20; + +void take_snapshot(std::size_t i) +{ + std::cerr << " snapshot " << i << " / " << N << std::endl; + // This is not doing what we thing it does.. it is better to control the + // snapshot generation with something like this: + // + // --max-snapshots=1000 --detailed-freq=1 + // + // VALGRIND_MONITOR_COMMAND("detailed_snapshot"); + // VALGRIND_MONITOR_COMMAND("all_snapshots"); +} +} // namespace basic_params + +template +auto benchmark_memory_basic_std() +{ + using namespace basic_params; + + std::cerr << "running... " << boost::core::demangle(typeid(Set).name()) + << std::endl; + + auto rs = std::vector{}; + auto g = Generator{}(); + auto v = Set{}; + + take_snapshot(0); + for (auto i = 0u; i < N; ++i) { + v.insert(g()); + } + take_snapshot(N); + + volatile auto dont_optimize_ = v.size(); + return dont_optimize_; +} + +template +auto benchmark_memory_basic() +{ + using namespace basic_params; + + std::cerr << "running... " << boost::core::demangle(typeid(Set).name()) + << std::endl; + + auto g = Generator{}(); + auto v = Set{}; + + take_snapshot(0); + for (auto i = 0u; i < N; ++i) { + v = std::move(v).insert(g()); + } + take_snapshot(N); + + volatile auto dont_optimize_ = v.size(); + return dont_optimize_; +} + +namespace exp_params { +constexpr auto N = 1 << 20; +constexpr auto E = 2; + +void take_snapshot(std::size_t i) +{ + std::cerr << " snapshot " << i << " / " << N << std::endl; + // This is not doing what we thing it does.. it is better to control the + // snapshot generation with something like this: + // + // --max-snapshots=1000 --detailed-freq=1 + // + // VALGRIND_MONITOR_COMMAND("detailed_snapshot"); + // VALGRIND_MONITOR_COMMAND("all_snapshots"); +} +} // namespace exp_params + +template +auto benchmark_memory_exp_std() +{ + using namespace exp_params; + + std::cerr << "running... " << boost::core::demangle(typeid(Set).name()) + << std::endl; + + auto rs = std::vector{}; + auto g = Generator{}(); + auto v = Set{}; + + take_snapshot(0); + for (auto i = 0u, n = 1u; i < N; ++i) { + if (i == n) { + rs.push_back(v); + n *= E; + take_snapshot(i); + } + v.insert(g()); + } + take_snapshot(N); + + volatile auto dont_optimize_ = rs.data(); + return dont_optimize_; +} + +template +auto benchmark_memory_exp() +{ + using namespace exp_params; + + std::cerr << "running... " << boost::core::demangle(typeid(Set).name()) + << std::endl; + + auto rs = std::vector{}; + auto g = Generator{}(); + auto v = Set{}; + + take_snapshot(0); + for (auto i = 0u, n = 1u; i < N; ++i) { + if (i == n) { + rs.push_back(v); + n *= E; + take_snapshot(i); + } + v = std::move(v).insert(g()); + } + take_snapshot(N); + + volatile auto dont_optimize_ = rs.data(); + return dont_optimize_; +} + +namespace lin_params { +constexpr auto N = 1 << 14; +constexpr auto M = 1 << 7; +constexpr auto S = 1; + +void take_snapshot(std::size_t i) +{ + std::cerr << " snapshot " << i << " / " << M << std::endl; + // This is not doing what we thing it does.. it is better to control the + // snapshot generation with something like this: + // + // --max-snapshots=1000 --detailed-freq=1 + // + // VALGRIND_MONITOR_COMMAND("detailed_snapshot"); + // VALGRIND_MONITOR_COMMAND("all_snapshots"); +} +} // namespace lin_params + +template +auto benchmark_memory_lin_std() +{ + using namespace lin_params; + + std::cerr << "running... " << boost::core::demangle(typeid(Map).name()) + << std::endl; + + auto rs = std::vector{}; + auto ks = std::vector{}; + auto g = Generator{}(); + auto v = Map{}; + auto ug = generate_unsigned{}(); + + take_snapshot(0); + for (auto i = 0u; i < N; ++i) { + auto k = g(); + v.insert({k, 0u}); + ks.push_back(std::move(k)); + } + take_snapshot(N); + + take_snapshot(0); + for (auto i = 0u; i < M; ++i) { + for (auto j = 0u; j < S; ++j) { + auto&& k = ks[ug() % ks.size()]; + ++v.at(k); + } + rs.push_back(v); + take_snapshot(i); + } + take_snapshot(M); + + volatile auto dont_optimize_ = rs.data(); + return dont_optimize_; +} + +template +auto benchmark_memory_lin() +{ + using namespace lin_params; + + std::cerr << "running... " << boost::core::demangle(typeid(Map).name()) + << std::endl; + + auto rs = std::vector{}; + auto ks = std::vector{}; + auto g = Generator{}(); + auto v = Map{}; + auto ug = generate_unsigned{}(); + + take_snapshot(0); + for (auto i = 0u; i < N; ++i) { + auto k = g(); + v = std::move(v).insert({k, 0u}); + ks.push_back(std::move(k)); + } + take_snapshot(N); + + take_snapshot(0); + for (auto i = 0u; i < M; ++i) { + for (auto j = 0u; j < S; ++j) { + auto&& k = ks[ug() % ks.size()]; + v = std::move(v).update(k, [](auto x) { return ++x; }); + } + rs.push_back(v); + take_snapshot(i); + } + take_snapshot(M); + + volatile auto dont_optimize_ = rs.data(); + return dont_optimize_; +} + +#if IMMER_BENCHMARK_MEMORY_STRING_SHORT +using generator__ = generate_string_short; +using t__ = std::string; +#elif IMMER_BENCHMARK_MEMORY_STRING_LONG +using generator__ = generate_string_long; +using t__ = std::string; +#elif IMMER_BENCHMARK_MEMORY_UNSIGNED +using generator__ = generate_unsigned; +using t__ = unsigned; +#else +#error "choose some type!" +#endif + +int main_basic() +{ + benchmark_memory_basic_std>(); + benchmark_memory_basic_std>(); + + // too slow, why? + // benchmark_memory_basic_std>(); + + // very bad... just ignore... + // benchmark_memory_basic_std>(); + + using def_memory = immer::default_memory_policy; + + benchmark_memory_basic< + generator__, + immer::set, std::equal_to, def_memory, 2>>(); + benchmark_memory_basic< + generator__, + immer::set, std::equal_to, def_memory, 3>>(); + benchmark_memory_basic< + generator__, + immer::set, std::equal_to, def_memory, 4>>(); + benchmark_memory_basic< + generator__, + immer::set, std::equal_to, def_memory, 5>>(); + benchmark_memory_basic< + generator__, + immer::set, std::equal_to, def_memory, 6>>(); + + return 0; +} + +int main_exp() +{ + benchmark_memory_exp_std>(); + benchmark_memory_exp_std>(); + + // too slow, why? + // benchmark_memory_exp_std>(); + + // very bad... just ignore... + // benchmark_memory_exp_std>(); + + using def_memory = immer::default_memory_policy; + + benchmark_memory_exp< + generator__, + immer::set, std::equal_to, def_memory, 2>>(); + benchmark_memory_exp< + generator__, + immer::set, std::equal_to, def_memory, 3>>(); + benchmark_memory_exp< + generator__, + immer::set, std::equal_to, def_memory, 4>>(); + benchmark_memory_exp< + generator__, + immer::set, std::equal_to, def_memory, 5>>(); + benchmark_memory_exp< + generator__, + immer::set, std::equal_to, def_memory, 6>>(); + + return 0; +} + +int main_lin() +{ + benchmark_memory_lin_std>(); + benchmark_memory_lin_std>(); + + // too slow, why? + // benchmark_memory_lin_std>(); + + // very bad... just ignore... + // benchmark_memory_lin_std>(); + + using def_memory = immer::default_memory_policy; + + benchmark_memory_lin, + std::equal_to, + def_memory, + 2>>(); + benchmark_memory_lin, + std::equal_to, + def_memory, + 3>>(); + benchmark_memory_lin, + std::equal_to, + def_memory, + 4>>(); + benchmark_memory_lin, + std::equal_to, + def_memory, + 5>>(); + benchmark_memory_lin, + std::equal_to, + def_memory, + 6>>(); + + return 0; +} diff --git a/benchmark/set/string-box/erase.cpp b/benchmark/set/string-box/erase.cpp new file mode 100644 index 00000000..88191ada --- /dev/null +++ b/benchmark/set/string-box/erase.cpp @@ -0,0 +1,11 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "generator.ipp" + +#include "../erase.ipp" diff --git a/benchmark/set/string-long/erase.cpp b/benchmark/set/string-long/erase.cpp new file mode 100644 index 00000000..88191ada --- /dev/null +++ b/benchmark/set/string-long/erase.cpp @@ -0,0 +1,11 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "generator.ipp" + +#include "../erase.ipp" diff --git a/benchmark/set/string-short/erase.cpp b/benchmark/set/string-short/erase.cpp new file mode 100644 index 00000000..88191ada --- /dev/null +++ b/benchmark/set/string-short/erase.cpp @@ -0,0 +1,11 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "generator.ipp" + +#include "../erase.ipp" diff --git a/benchmark/set/unsigned/erase.cpp b/benchmark/set/unsigned/erase.cpp new file mode 100644 index 00000000..88191ada --- /dev/null +++ b/benchmark/set/unsigned/erase.cpp @@ -0,0 +1,11 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "generator.ipp" + +#include "../erase.ipp" diff --git a/cmake/FindGuile.cmake b/cmake/FindGuile.cmake deleted file mode 100644 index 2b8781c4..00000000 --- a/cmake/FindGuile.cmake +++ /dev/null @@ -1,326 +0,0 @@ -#[[.rst -# -# FindGuile -# --------- -# Find the development libraries for Guile. -# -# Exported Vars -# ~~~~~~~~~~~~~ -# -# .. variable:: Guile_FOUND -# -# Set to *true* if Guile was found. -# -# .. variable:: Guile_INCLUDE_DIRS -# -# A list of include directories. -# -# .. variable:: Guile_LIBRARIES -# -# A list of libraries needed to build you project. -# -# .. variable:: Guile_VERSION_STRING -# -# Guile full version. -# -# .. variable:: Guile_VERSION_MAJOR -# -# Guile major version. -# -# .. variable:: Guile_VERSION_MINOR -# -# Guile minor version. -# -# .. variable:: Guile_VERSION_PATCH -# -# Guile patch version. -# -# .. variable:: Guile_EXECUTABLE -# -# Guile executable (optional). -# -# .. variable:: Guile_CONFIG_EXECUTABLE -# -# Guile configuration executable (optional). -# -# .. variable:: Guile_ROOT_DIR -# -# Guile installation root dir (optional). -# -# .. variable:: Guile_SITE_DIR -# -# Guile installation module site dir (optional). -# -# .. variable:: Guile_EXTENSION_DIR -# -# Guile installation extension dir (optional). -# -# Control VARS -# ~~~~~~~~~~~~ -# :envvar:`Guile_ROOT_DIR` -# -# Use this variable to provide hints to :filename:`find_{*}` commands, -# you may pass it to :command:`cmake` or set the environtment variable. -# -# .. code-block:: cmake -# -# % cmake . -Bbuild -DGuile_ROOT_DIR= -# -# # or -# % export Guile_ROOT_DIR=; -# % cmake . -Bbuild -# -# # or -# % Guile_ROOT_DIR= cmake . -Bbuild -# -# -#]] - - -#[[.rst -# -# Copyright © 2016, Edelcides Gonçalves -# -# Permission to use, copy, modify, and/or distribute this software for -# any purpose with or without fee is hereby granted, provided that the -# above copyright notice and this permission notice appear in all -# copies. -# -# *THE SOFTWARE IS PROVIDED* **AS IS** *AND ISC DISCLAIMS ALL -# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED -# WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE -# LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES -# OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR -# PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER -# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR -# PERFORMANCE OF THIS SOFTWARE*. -# -# This file is not part of CMake -# -#]] - - -include (SelectLibraryConfigurations) -include (FindPackageHandleStandardArgs) - -function (_guile_find_component_include_dir component header) - find_path ("${component}_INCLUDE_DIR" - ${header} - HINTS - "${GUile_ROOT_DIR}" - ENV Guile_ROOT_DIR - PATH_SUFFIXES - Guile guile Guile-2.0 guile-2.0 Guile/2.0 guile/2.0 GC - gc) - - set ("${component}_INCLUDE_DIR" "${${component}_INCLUDE_DIR}" - PARENT_SCOPE) -endfunction () - -function (_guile_find_component_library component_name component) - - find_library ("${component_name}_LIBRARY_RELEASE" - NAMES "${component}" "${component}-2.0" - HINTS - "${GUile_ROOT_DIR}" - ENV Guile_ROOT_DIR - PATHS - /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE} - /usr/lib64/${CMAKE_LIBRARY_ARCHITECTURE} - /usr/lib32/${CMAKE_LIBRARY_ARCHITECTURE}) - - if (${component_name}_LIBRARY_RELEASE) - select_library_configurations (${component_name}) - set ("${component_name}_LIBRARY_RELEASE" - "${${component_name}_LIBRARY_RELEASE}" PARENT_SCOPE) - set ("${component_name}_LIBRARY" - "${${component_name}_LIBRARY}" PARENT_SCOPE) - set ("${component_name}_LIBRARIES" - "${${component_name}_LIBRARIES}" PARENT_SCOPE) - endif () -endfunction () - -function (_guile_find_version_2 header_file macro_name) - file (STRINGS "${header_file}" _VERSION - REGEX "#define[\t ]+${macro_name}[\t ]+[0-9]+") - - if (_VERSION) - string (REGEX REPLACE - ".*#define[\t ]+${macro_name}[\t ]+([0-9]+).*" - "\\1" _VERSION_VALUE "${_VERSION}") - if ("${_VERSION}" STREQUAL "${_VERSION_VALUE}") - set (_VERSION_FOUND 0 PARENT_SCOPE) - else () - set (_VERSION_FOUND 1 PARENT_SCOPE) - set (_VERSION "${_VERSION_VALUE}" PARENT_SCOPE) - endif () - else () - set (_VERSION_FOUND 0 PARENT_SCOPE) - endif () -endfunction () - - -##### Entry Point ##### - -set (Guile_FOUND) -set (Guile_INCLUDE_DIRS) -set (Guile_LIBRARIES) -set (Guile_VERSION_STRING) -set (Guile_VERSION_MAJOR) -set (Guile_VERSION_MINOR) -set (Guile_VERSION_PATCH) -set (Guile_EXECUTABLE) - -_guile_find_component_include_dir (Guile "libguile.h") -if (Guile_INCLUDE_DIR) - _guile_find_version_2 ("${Guile_INCLUDE_DIR}/libguile/version.h" - SCM_MAJOR_VERSION) - if (_VERSION_FOUND) - set (Guile_VERSION_MAJOR "${_VERSION}") - else () - message (FATAL_ERROR "FindGuile: Failed to find Guile_MAJOR_VERSION.") - endif () - - _guile_find_version_2 ("${Guile_INCLUDE_DIR}/libguile/version.h" - SCM_MINOR_VERSION) - if (_VERSION_FOUND) - set (Guile_VERSION_MINOR "${_VERSION}") - else () - message (FATAL_ERROR "FindGuile: Failed to find Guile_MINOR_VERSION.") - endif () - - _guile_find_version_2 ("${Guile_INCLUDE_DIR}/libguile/version.h" - SCM_MICRO_VERSION) - if (_VERSION_FOUND) - set (Guile_VERSION_PATCH "${_VERSION}") - else () - message (FATAL_ERROR "FindGuile: Failed to find Guile_MICRO_VERSION.") - endif () - set (Guile_VERSION_STRING "${Guile_VERSION_MAJOR}.${Guile_VERSION_MINOR}.${Guile_VERSION_PATCH}") - - unset (_VERSION_FOUND) - unset (_VERSION) -endif () - -_guile_find_component_include_dir (Guile_GC "gc.h") -_guile_find_component_library (Guile guile) -_guile_find_component_library (Guile_GC gc) - -find_program (Guile_EXECUTABLE - guile - DOC "Guile executable.") - -if (Guile_EXECUTABLE) - execute_process (COMMAND ${Guile_EXECUTABLE} --version - RESULT_VARIABLE _status - OUTPUT_VARIABLE _output - OUTPUT_STRIP_TRAILING_WHITESPACE) - - string (REGEX REPLACE ".*\\(GNU Guile\\)[\t ]+([0-9]+)\\..*" "\\1" - _guile_ver_major "${_output}") - - string (REGEX REPLACE ".*\\(GNU Guile\\)[\t ]+[0-9]+\\.([0-9]+).*" "\\1" - _guile_ver_minor "${_output}") - - string (REGEX REPLACE ".*\\(GNU Guile\\)[\t ]+[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" - _guile_ver_patch "${_output}") - - set (_version "${_guile_ver_major}.${_guile_ver_minor}.${_guile_ver_patch}") - - if (NOT Guile_FIND_QUIETLY) - if (NOT Guile_VERSION_STRING STREQUAL _version) - message (WARNING "FindGuile: Versions provided by library differs from the one provided by executable.") - endif () - - if (NOT _status STREQUAL "0") - message (WARNING "FindGuile: guile (1) process exited abnormally.") - endif () - endif () - - unset (_version) - unset (_status) - unset (_version) - unset (_guile_ver_major) - unset (_guile_ver_minor) - unset (_guile_ver_patch) -endif () - -find_package_handle_standard_args (GC - "FindGuile: Failed to find dependency GC." - Guile_GC_INCLUDE_DIR - Guile_GC_LIBRARY - Guile_GC_LIBRARIES - Guile_GC_LIBRARY_RELEASE) - -find_package_handle_standard_args (Guile - REQUIRED_VARS - Guile_INCLUDE_DIR - Guile_LIBRARY - Guile_LIBRARIES - Guile_LIBRARY_RELEASE - GC_FOUND - VERSION_VAR Guile_VERSION_STRING) - -if (Guile_FOUND) - list (APPEND Guile_INCLUDE_DIRS "${Guile_INCLUDE_DIR}" - "${Guile_GC_INCLUDE_DIR}") - - if (NOT TARGET Guile::Library AND NOT TARGET GC::Library) - add_library (Guile::GC::Library UNKNOWN IMPORTED) - set_property (TARGET Guile::GC::Library APPEND - PROPERTY IMPORTED_CONFIGURATIONS RELEASE) - - set_target_properties (Guile::GC::Library - PROPERTIES - INTERFACE_INCLUDE_DIRS - "${Guile_GC_INCLUDE_DIR}" - IMPORTED_LOCATION - "${Guile_GC_LIBRARY}" - IMPORTED_LOCATION_RELEASE - "${Guile_GC_LIBRARY_RELEASE}") - - add_library (Guile::Library UNKNOWN IMPORTED) - set_property (TARGET Guile::Library APPEND - PROPERTY IMPORTED_CONFIGURATIONS RELEASE) - set_property (TARGET Guile::Library APPEND - PROPERTY - INTERFACE_LINK_LIBRARIES - Guile::GC::Library) - - set_target_properties (Guile::Library - PROPERTIES - INTERFACE_INCLUDE_DIRSr - "${Guile_INCLUDE_DIR}" - IMPORTED_LOCATION "${Guile_LIBRARY}" - IMPORTED_LOCATION_RELEASE - "${Guile_LIBRARY_RELEASE}") - - set (Guile_LIBRARIES Guile::Library Guile::GC::Library) - endif () -endif () - -find_program(Guile_CONFIG_EXECUTABLE - NAMES guile-config - DOC "Guile configutration binary") - -if (Guile_CONFIG_EXECUTABLE) - execute_process (COMMAND ${Guile_CONFIG_EXECUTABLE} info prefix - OUTPUT_VARIABLE Guile_ROOT_DIR - OUTPUT_STRIP_TRAILING_WHITESPACE) - - execute_process (COMMAND ${Guile_CONFIG_EXECUTABLE} info sitedir - OUTPUT_VARIABLE Guile_SITE_DIR - OUTPUT_STRIP_TRAILING_WHITESPACE) - - execute_process (COMMAND ${Guile_CONFIG_EXECUTABLE} info extensiondir - OUTPUT_VARIABLE Guile_EXTENSION_DIR - OUTPUT_STRIP_TRAILING_WHITESPACE) -endif () - -mark_as_advanced (Guile_EXECUTABLE - Guile_INCLUDE_DIR - Guile_LIBRARY - Guile_LIBRARY_RELEASE - Guile_GC_INCLUDE_DIR - Guile_GC_LIBRARY - Guile_GC_LIBRARY_RELEASE) diff --git a/default.nix b/default.nix index 1a6f0296..b2ab20d0 100644 --- a/default.nix +++ b/default.nix @@ -1,11 +1,33 @@ -with import {}; +{ pkgs ? import {} }: +with pkgs; + +let + inherit (import (pkgs.fetchFromGitHub { + owner = "hercules-ci"; + repo = "gitignore.nix"; + rev = "80463148cd97eebacf80ba68cf0043598f0d7438"; + sha256 = "1l34rmh4lf4w8a1r8vsvkmg32l1chl0p593fl12r28xx83vn150v"; + }) {}) gitignoreSource; + + nixFilter = name: type: !(lib.hasSuffix ".nix" name); + srcFilter = src: lib.cleanSourceWith { + filter = nixFilter; + src = gitignoreSource src; + }; + +in stdenv.mkDerivation rec { name = "immer-git"; version = "git"; - src = fetchGit ./.; + src = srcFilter ./.; nativeBuildInputs = [ cmake ]; dontBuild = true; + dontUseCmakeBuildDir = true; + cmakeFlags = [ + "-Dimmer_BUILD_TESTS=OFF" + "-Dimmer_BUILD_EXAMPLES=OFF" + ]; meta = { homepage = "https://github.com/arximboldi/immer"; description = "Postmodern immutable data structures for C++"; diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt index 8558a3ec..7435dfe0 100644 --- a/doc/CMakeLists.txt +++ b/doc/CMakeLists.txt @@ -4,11 +4,11 @@ add_custom_target(doxygen COMMAND doxygen doxygen.config - WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/doc") + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_custom_target(docs COMMAND make html - WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/doc") + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_dependencies(docs doxygen) set(immer_ssh_method @@ -18,5 +18,5 @@ set(immer_ssh_method add_custom_target(upload-docs COMMAND rsync -av -e \"${immer_ssh_method}\" - ${CMAKE_SOURCE_DIR}/doc/_build/html/* + ${CMAKE_CURRENT_SOURCE_DIR}/_build/html/* raskolnikov@sinusoid.es:public/immer/) diff --git a/doc/containers.rst b/doc/containers.rst index c6913ba4..5bec7889 100644 --- a/doc/containers.rst +++ b/doc/containers.rst @@ -48,3 +48,10 @@ map .. doxygenclass:: immer::map :members: :undoc-members: + +table +----- + +.. doxygenclass:: immer::table + :members: + :undoc-members: diff --git a/doc/design.rst b/doc/design.rst index 27d29e9e..f1848f53 100644 --- a/doc/design.rst +++ b/doc/design.rst @@ -18,7 +18,7 @@ internally, common data with other objects. We sometimes refer to this property as **structural sharing**. This behaviour is transparent to the user. -Assigment +Assignment --------- We are sorry, we lied. These containers provide *one mutating @@ -79,14 +79,14 @@ removing it, as in: :end-before: move-good/end So, is it bad style then to use ``const`` as much as possible? I -wouldn't say so and it is advisable when ``std::move()`` is not used. -An alternative style is to not use ``const`` but adopt an `AAA-style -`_ (*Almost Always use Auto*). This way, it is easy to look for +wouldn't say so, and it is advisable when ``std::move()`` is not used. +An alternative style is to not use ``const`` but adopt an `AAA-style`_ +(*Almost Always use Auto*). This way, it is easy to look for mutations by looking for lines that contain ``=`` but no ``auto``. Remember that when using our immutable containers ``operator=`` is the only way to mutate a variable. -.. _aaa: https://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/ +.. _AAA-style: https://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/ .. admonition:: Why does ``const`` prevent move semantics? @@ -149,7 +149,7 @@ mutate part of the internal data structure in place when possible. If you don't like this syntax, :doc:`transients` may be used to obtain similar performance benefits. -.. admonition:: Assigment guarantees +.. admonition:: Assignment guarantees From the language point of view, the only requirement on moved from values is that they should still be destructible. We provide the @@ -208,7 +208,7 @@ Efficient batch manipulations Sometimes you may write a function that needs to do multiple changes to a container. Like most code you write with this library, this function is *pure*: it takes one container value in, and produces a -new container value out, no side-effects. +new container value out, no side effects. Let's say we want to write a function that inserts all integers in the range :math:`[first, last)` into an immutable vector: diff --git a/doc/memory.rst b/doc/memory.rst index 3138b249..ba8ec175 100644 --- a/doc/memory.rst +++ b/doc/memory.rst @@ -1,7 +1,7 @@ Memory management ================= -Memory management is specially important for immutable data +Memory management is especially important for immutable data structures. This is mainly due to: #. In order to preserve the old value, new memory has to be allocated @@ -39,7 +39,7 @@ Memory policy Example: tracing garbage collection ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -It is note worthy that all aspects of a +It is noteworthy that all aspects of a :cpp:class:`immer::memory_policy` are not completely orthogonal. Let's say you want to use a `tracing garbage collector`_. Actually, we @@ -79,7 +79,7 @@ allocate objects of those sizes. .. _metafunction class: http://www.boost.org/doc/libs/1_62_0/libs/mpl/doc/refmanual/metafunction-class.html -A **heap** is a type with a methods ``void* allocate(std::size_t)`` +A **heap** is a type with methods ``void* allocate(std::size_t)`` and ``void deallocate(void*)`` that return and release raw memory. For a canonical model of this concept check the :cpp:class:`immer::cpp_heap`. @@ -95,8 +95,8 @@ For a canonical model of this concept check the On the other hand, having some **scoped state** does make sense for some use-cases of immutable data structures. For example, we might want to support variations of `region - based allocation`_. This interface might evolve to evolve - to support some kind of non-global state to accommodate + based allocation`_. This interface might evolve to support + some kind of non-global state to accommodate these use cases. .. _region based allocation: https://en.wikipedia.org/wiki/Region-based_memory_management @@ -143,7 +143,7 @@ Heap adaptors Inspired by `Andrei Alexandrescu's talk on allocators `_ and `Emery Berger's heap layers `_ we provide allocator adaptors that can be combined using C++ mixins. These -enable building more complex allocator out of simpler strategies, or +enable building more complex allocators out of simpler strategies, or provide application specific optimizations on top of general allocators. diff --git a/doc/transients.rst b/doc/transients.rst index 9b385d4d..461bb4ac 100644 --- a/doc/transients.rst +++ b/doc/transients.rst @@ -4,9 +4,9 @@ Transients ========== *Transients* is a concept borrowed `from Clojure -`_, with some twists to turn make more idiomatic +`_, with some twists to make it more idiomatic in C++. Essentially, they are a mutable interface built on top of the -same data structures the implements the immutable containers under the +same data structures that implement the immutable containers under the hood. These can be useful for :ref:`performing efficient batch @@ -49,3 +49,10 @@ map_transient .. doxygenclass:: immer::map_transient :members: :undoc-members: + +table_transient +--------------- + +.. doxygenclass:: immer::table_transient + :members: + :undoc-members: diff --git a/example/table/intro.cpp b/example/table/intro.cpp new file mode 100644 index 00000000..67c83f9f --- /dev/null +++ b/example/table/intro.cpp @@ -0,0 +1,29 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// +#include +// include:intro/start +#include + +int main() +{ + struct Item + { + std::string id; + int value; + }; + + const auto v0 = immer::table{}; + const auto v1 = v0.insert({"hello", 42}); + assert(v0["hello"].value == 0); + assert(v1["hello"].value == 42); + + const auto v2 = v1.erase("hello"); + assert(v1.find("hello")->value == 42); + assert(!v2.find("hello")); +} +// include:intro/end diff --git a/extra/fuzzer/fuzzer_input.hpp b/extra/fuzzer/fuzzer_input.hpp index 52d5c390..22def081 100644 --- a/extra/fuzzer/fuzzer_input.hpp +++ b/extra/fuzzer/fuzzer_input.hpp @@ -12,6 +12,10 @@ #include #include +#if defined(__GNUC__) && (__GNUC__ == 9 || __GNUC__ == 8 || __GNUC__ == 10) +#define IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG 1 +#endif + struct no_more_input : std::exception {}; diff --git a/extra/fuzzer/map-gc.cpp b/extra/fuzzer/map-gc.cpp index e5bea5da..556df956 100644 --- a/extra/fuzzer/map-gc.cpp +++ b/extra/fuzzer/map-gc.cpp @@ -13,6 +13,8 @@ #include #include +#include + #include using gc_memory = immer::memory_policy, @@ -49,7 +51,11 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, op_erase_move, op_iterate, op_find, - op_update + op_update, + op_update_move, + op_update_if_exists, + op_update_if_exists_move, + op_diff }; auto src = read(in, is_valid_var); auto dst = read(in, is_valid_var); @@ -94,6 +100,43 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, vars[dst] = vars[src].update(key, [](int x) { return x + 1; }); break; } + case op_update_move: { + auto key = read(in); + vars[dst] = + std::move(vars[src]).update(key, [](int x) { return x + 1; }); + break; + } + case op_update_if_exists: { + auto key = read(in); + vars[dst] = + vars[src].update_if_exists(key, [](int x) { return x + 1; }); + break; + } + case op_update_if_exists_move: { + auto key = read(in); + vars[dst] = std::move(vars[src]).update_if_exists( + key, [](int x) { return x + 1; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } default: break; }; diff --git a/extra/fuzzer/map-st-str-conflict.cpp b/extra/fuzzer/map-st-str-conflict.cpp new file mode 100644 index 00000000..7da68547 --- /dev/null +++ b/extra/fuzzer/map-st-str-conflict.cpp @@ -0,0 +1,136 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "fuzzer_input.hpp" + +#include +#include + +#include + +#include + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(const std::string& x) const + { + return std::hash{}(x) & ~((std::size_t{1} << 48) - 1); + } +}; + +extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, + std::size_t size) +{ + constexpr auto var_count = 4; + + using map_t = immer::map, + colliding_hash_t, + std::equal_to<>, + st_memory, + 3>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_set, + op_erase, + op_set_move, + op_erase_move, + op_iterate, + op_find, + op_update, + op_update_move, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + assert(vars[src].impl().check_champ()); + switch (read(in)) { + case op_set: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].set(value, "foo"); + break; + } + case op_erase: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].erase(value); + break; + } + case op_set_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).set(value, "foo"); + break; + } + case op_erase_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].set(v.first, v.second); + } + break; + } + case op_find: { + auto value = std::to_string(read(in)); + auto res = vars[src].find(value); + if (res != nullptr) { + vars[dst] = vars[dst].set(*res, "foo"); + } + break; + } + case op_update: { + auto key = std::to_string(read(in)); + vars[dst] = vars[src].update( + key, [](std::string x) { return std::move(x) + "bar"; }); + break; + } + case op_update_move: { + auto key = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).update( + key, [](std::string x) { return std::move(x) + "baz"; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } + default: + break; + }; + return true; + }); +} diff --git a/extra/fuzzer/map-st-str.cpp b/extra/fuzzer/map-st-str.cpp new file mode 100644 index 00000000..40770961 --- /dev/null +++ b/extra/fuzzer/map-st-str.cpp @@ -0,0 +1,135 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "fuzzer_input.hpp" + +#include +#include + +#include + +#include + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(const std::string& x) const + { + return std::hash{}(x) & ~15; + } +}; + +extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, + std::size_t size) +{ + constexpr auto var_count = 4; + + using map_t = immer::map, + colliding_hash_t, + std::equal_to<>, + st_memory>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_set, + op_erase, + op_set_move, + op_erase_move, + op_iterate, + op_find, + op_update, + op_update_move, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + assert(vars[src].impl().check_champ()); + switch (read(in)) { + case op_set: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].set(value, "foo"); + break; + } + case op_erase: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].erase(value); + break; + } + case op_set_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).set(value, "foo"); + break; + } + case op_erase_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].set(v.first, v.second); + } + break; + } + case op_find: { + auto value = std::to_string(read(in)); + auto res = vars[src].find(value); + if (res != nullptr) { + vars[dst] = vars[dst].set(*res, "foo"); + } + break; + } + case op_update: { + auto key = std::to_string(read(in)); + vars[dst] = vars[src].update( + key, [](std::string x) { return std::move(x) + "bar"; }); + break; + } + case op_update_move: { + auto key = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).update( + key, [](std::string x) { return std::move(x) + "baz"; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } + default: + break; + }; + return true; + }); +} diff --git a/extra/fuzzer/map-st.cpp b/extra/fuzzer/map-st.cpp index d9abdeb2..6a0a96ff 100644 --- a/extra/fuzzer/map-st.cpp +++ b/extra/fuzzer/map-st.cpp @@ -10,6 +10,8 @@ #include +#include + #include using st_memory = immer::memory_policy, @@ -44,7 +46,9 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, op_erase_move, op_iterate, op_find, - op_update + op_update, + op_update_move, + op_diff }; auto src = read(in, is_valid_var); auto dst = read(in, is_valid_var); @@ -89,6 +93,31 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, vars[dst] = vars[src].update(key, [](int x) { return x + 1; }); break; } + case op_update_move: { + auto key = read(in); + vars[dst] = + std::move(vars[src]).update(key, [](int x) { return x + 1; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } default: break; }; diff --git a/extra/fuzzer/map.cpp b/extra/fuzzer/map.cpp index 1112b969..e5d4ce33 100644 --- a/extra/fuzzer/map.cpp +++ b/extra/fuzzer/map.cpp @@ -10,6 +10,8 @@ #include +#include + #include struct colliding_hash_t @@ -37,7 +39,11 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, op_erase_move, op_iterate, op_find, - op_update + op_update, + op_update_move, + op_update_if_exists, + op_update_if_exists_move, + op_diff, }; auto src = read(in, is_valid_var); auto dst = read(in, is_valid_var); @@ -82,6 +88,43 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, vars[dst] = vars[src].update(key, [](int x) { return x + 1; }); break; } + case op_update_move: { + auto key = read(in); + vars[dst] = + std::move(vars[src]).update(key, [](int x) { return x + 1; }); + break; + } + case op_update_if_exists: { + auto key = read(in); + vars[dst] = + vars[src].update_if_exists(key, [](int x) { return x + 1; }); + break; + } + case op_update_if_exists_move: { + auto key = read(in); + vars[dst] = std::move(vars[src]).update_if_exists( + key, [](int x) { return x + 1; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } default: break; }; diff --git a/extra/fuzzer/set-gc.cpp b/extra/fuzzer/set-gc.cpp index 994daa8d..55382e79 100644 --- a/extra/fuzzer/set-gc.cpp +++ b/extra/fuzzer/set-gc.cpp @@ -49,7 +49,8 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, op_erase, op_insert_move, op_erase_move, - op_iterate + op_iterate, + op_diff }; auto src = read(in, is_valid_var); auto dst = read(in, is_valid_var); @@ -81,6 +82,22 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, }); break; } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } default: break; }; diff --git a/extra/fuzzer/set-st-str-conflict.cpp b/extra/fuzzer/set-st-str-conflict.cpp new file mode 100644 index 00000000..bf00873a --- /dev/null +++ b/extra/fuzzer/set-st-str-conflict.cpp @@ -0,0 +1,108 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "fuzzer_input.hpp" + +#include +#include +#include +#include + +#include + +#include + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(const std::string& x) const + { + return std::hash{}(x) & ~((std::size_t{1} << 48) - 1); + } +}; + +extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, + std::size_t size) +{ + constexpr auto var_count = 4; + + using set_t = immer:: + set, st_memory, 3>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_insert, + op_erase, + op_insert_move, + op_erase_move, + op_iterate, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + assert(vars[src].impl().check_champ()); + switch (read(in)) { + case op_insert: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].insert(value); + break; + } + case op_erase: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].erase(value); + break; + } + case op_insert_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).insert(value); + break; + } + case op_erase_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].insert(v); + } + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } + default: + break; + }; + return true; + }); +} diff --git a/extra/fuzzer/set-st-str.cpp b/extra/fuzzer/set-st-str.cpp new file mode 100644 index 00000000..e5fc1137 --- /dev/null +++ b/extra/fuzzer/set-st-str.cpp @@ -0,0 +1,108 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "fuzzer_input.hpp" + +#include +#include +#include +#include + +#include + +#include + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(const std::string& x) const + { + return std::hash{}(x) & ~15; + } +}; + +extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, + std::size_t size) +{ + constexpr auto var_count = 4; + + using set_t = + immer::set, st_memory>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_insert, + op_erase, + op_insert_move, + op_erase_move, + op_iterate, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + assert(vars[src].impl().check_champ()); + switch (read(in)) { + case op_insert: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].insert(value); + break; + } + case op_erase: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].erase(value); + break; + } + case op_insert_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).insert(value); + break; + } + case op_erase_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].insert(v); + } + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } + default: + break; + }; + return true; + }); +} diff --git a/extra/fuzzer/set-st.cpp b/extra/fuzzer/set-st.cpp index 07353f04..fe7c8201 100644 --- a/extra/fuzzer/set-st.cpp +++ b/extra/fuzzer/set-st.cpp @@ -12,6 +12,8 @@ #include #include +#include + #include using st_memory = immer::memory_policy, @@ -44,7 +46,8 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, op_erase, op_insert_move, op_erase_move, - op_iterate + op_iterate, + op_diff }; auto src = read(in, is_valid_var); auto dst = read(in, is_valid_var); @@ -66,7 +69,7 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, } case op_erase_move: { auto value = read(in); - vars[dst] = vars[src].erase(value); + vars[dst] = std::move(vars[src]).erase(value); break; } case op_iterate: { @@ -76,6 +79,22 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, } break; } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } default: break; }; diff --git a/extra/fuzzer/set.cpp b/extra/fuzzer/set.cpp index a00f126f..c225a8ce 100644 --- a/extra/fuzzer/set.cpp +++ b/extra/fuzzer/set.cpp @@ -8,6 +8,7 @@ #include "fuzzer_input.hpp" +#include #include #include @@ -35,7 +36,8 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, op_erase, op_insert_move, op_erase_move, - op_iterate + op_iterate, + op_diff }; auto src = read(in, is_valid_var); auto dst = read(in, is_valid_var); @@ -67,6 +69,22 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data, } break; } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } default: break; }; diff --git a/extra/guile/README.rst b/extra/guile/README.rst index 09cf8be6..879850b9 100644 --- a/extra/guile/README.rst +++ b/extra/guile/README.rst @@ -2,7 +2,7 @@ Guile bindings ============== -This library includes experimental bindings bring efficient immutable +This library includes experimental bindings that provide efficient immutable vectors for the `GNU Guile`_ Scheme implementation. The interface is somewhat **incomplete**, but you can already do something interesting things like: @@ -15,7 +15,7 @@ things like: **Do you want to help** making these bindings complete and production ready? Drop a line at `immer@sinusoid.al - `_ or `open an issue on Github + `_ or `open an issue on GitHub `_ .. _GNU Guile: https://www.gnu.org/software/guile/ diff --git a/extra/python/README.rst b/extra/python/README.rst index 7447e99e..4b6eb575 100644 --- a/extra/python/README.rst +++ b/extra/python/README.rst @@ -2,7 +2,7 @@ Python bindings =============== -This library includes experimental bindings bring efficient immutable +This library includes experimental bindings that provide efficient immutable vectors for the Python language. They were developed as part of the research for the `ICFP'17 paper`_. The interface is quite **incomplete**, yet you can already do some things like: @@ -15,7 +15,7 @@ research for the `ICFP'17 paper`_. The interface is quite **Do you want to help** making these bindings complete and production ready? Drop a line at `immer@sinusoid.al - `_ or `open an issue on Github + `_ or `open an issue on GitHub `_ Installation diff --git a/immer/algorithm.hpp b/immer/algorithm.hpp index 0b71c65c..382df02d 100644 --- a/immer/algorithm.hpp +++ b/immer/algorithm.hpp @@ -10,6 +10,7 @@ #include #include +#include #include #include @@ -92,6 +93,26 @@ bool for_each_chunk_p(const T* first, const T* last, Fn&& fn) return std::forward(fn)(first, last); } +namespace detail { + +template +T accumulate_move(Iter first, Iter last, T init) +{ + for (; first != last; ++first) + init = std::move(init) + *first; + return init; +} + +template +T accumulate_move(Iter first, Iter last, T init, Fn op) +{ + for (; first != last; ++first) + init = op(std::move(init), *first); + return init; +} + +} // namespace detail + /*! * Equivalent of `std::accumulate` applied to the range `r`. */ @@ -99,7 +120,7 @@ template T accumulate(Range&& r, T init) { for_each_chunk(r, [&](auto first, auto last) { - init = std::accumulate(first, last, init); + init = detail::accumulate_move(first, last, init); }); return init; } @@ -108,7 +129,7 @@ template T accumulate(Range&& r, T init, Fn fn) { for_each_chunk(r, [&](auto first, auto last) { - init = std::accumulate(first, last, init, fn); + init = detail::accumulate_move(first, last, init, fn); }); return init; } @@ -121,7 +142,7 @@ template T accumulate(Iterator first, Iterator last, T init) { for_each_chunk(first, last, [&](auto first, auto last) { - init = std::accumulate(first, last, init); + init = detail::accumulate_move(first, last, init); }); return init; } @@ -130,7 +151,7 @@ template T accumulate(Iterator first, Iterator last, T init, Fn fn) { for_each_chunk(first, last, [&](auto first, auto last) { - init = std::accumulate(first, last, init, fn); + init = detail::accumulate_move(first, last, init, fn); }); return init; } @@ -208,6 +229,97 @@ bool all_of(Iter first, Iter last, Pred p) }); } +/*! + * Object that can be used to process changes as computed by the @a diff + * algorithm. + * + * @tparam AddedFn Unary function that is be called whenever an added element is + * found. It is called with the added element as argument. + * + * @tparam RemovedFn Unary function that is called whenever a removed element is + * found. It is called with the removed element as argument. + * + * @tparam ChangedFn Unary function that is called whenever a changed element is + * found. It is called with the changed element as argument. + */ +template +struct differ +{ + AddedFn added; + RemovedFn removed; + ChangedFn changed; +}; + +/*! + * Produces a @a differ object with `added`, `removed` and `changed` functions. + */ +template +auto make_differ(AddedFn&& added, RemovedFn&& removed, ChangedFn&& changed) + -> differ, + std::decay_t, + std::decay_t> +{ + return {std::forward(added), + std::forward(removed), + std::forward(changed)}; +} + +/*! + * Produces a @a differ object with `added` and `removed` functions and no + * `changed` function. + */ +template +auto make_differ(AddedFn&& added, RemovedFn&& removed) +{ + return make_differ(std::forward(added), + std::forward(removed), + [](auto&&...) {}); +} + +/*! + * Compute the differences between `a` and `b`. + * + * Changes detected are notified via the differ object, which should support the + * following expressions: + * + * - `differ.added(x)`, invoked when element `x` is found in `b` but not in + * `a`. + * + * - `differ.removed(x)`, invoked when element `x` is found in `a` but not in + * `b`. + * + * - `differ.changed(x, y)`, invoked when element `x` and `y` from `a` and `b` + * share the same key but map to a different value. + * + * This method leverages structural sharing to offer a complexity @f$ O(|diff|) + * @f$ when `b` is derived from `a` by performing @f$ |diff| @f$ updates. This + * is, this function can detect changes in effectively constant time per update, + * as oposed to the @f$ O(|a|+|b|) @f$ complexity of a trivial implementation. + * + * @rst + * + * .. note:: This method is only implemented for ``map`` and ``set``. When sets + * are diffed, the ``changed`` function is never called. + * + * @endrst + */ +template +void diff(const T& a, const T& b, Differ&& differ) +{ + a.impl().template diff>( + b.impl(), std::forward(differ)); +} + +/*! + * Compute the differences between `a` and `b` using the callbacks in `fns` as + * differ. Equivalent to `diff(a, b, make_differ(fns)...)`. + */ +template +void diff(const T& a, const T& b, Fns&&... fns) +{ + diff(a, b, make_differ(std::forward(fns)...)); +} + /** @} */ // group: algorithm } // namespace immer diff --git a/immer/array.hpp b/immer/array.hpp index c86f4ea7..f71477c2 100644 --- a/immer/array.hpp +++ b/immer/array.hpp @@ -33,7 +33,7 @@ class array_transient; * .. tip:: Don't be fooled by the bad complexity of this data * structure. It is a great choice for short sequence or when it * is seldom or never changed. This depends on the ``sizeof(T)`` - * and the expensiveness of its ``T``'s copy constructor, in case + * and the expensiveness of its ``T``'s copy constructor. In case * of doubt, measure. For basic types, using an `array` when * :math:`n < 100` is a good heuristic. * @@ -91,7 +91,7 @@ class array {} /*! - * Constructs a array containing the element `val` repeated `n` + * Constructs an array containing the element `val` repeated `n` * times. */ array(size_type n, T v = {}) @@ -107,7 +107,8 @@ class array /*! * Returns an iterator pointing just after the last element of the - * collection. It does not allocate and its complexity is @f$ O(1) @f$. + * collection. It does not allocate memory and its complexity is @f$ O(1) + * @f$. */ IMMER_NODISCARD iterator end() const { return impl_.data() + impl_.size; } @@ -160,7 +161,7 @@ class array /*! * Returns a `const` reference to the element at position `index`. - * It is undefined when @f$ 0 index \geq size() @f$. It does not + * It is undefined when @f$ index \geq size() @f$. It does not * allocate memory and its complexity is *effectively* @f$ O(1) * @f$. */ @@ -308,6 +309,14 @@ class array return transient_type{std::move(impl_)}; } + /*! + * Returns a value that can be used as identity for the container. If two + * values have the same identity, they are guaranteed to be equal and to + * contain the same objects. However, two equal containers are not + * guaranteed to have the same identity. + */ + void* identity() const { return impl_.ptr; } + // Semi-private const impl_t& impl() const { return impl_; } diff --git a/immer/atom.hpp b/immer/atom.hpp index effde6ff..2cf409b9 100644 --- a/immer/atom.hpp +++ b/immer/atom.hpp @@ -129,7 +129,7 @@ struct gc_atom_impl * @rst * * .. warning:: If memory policy used includes thread unsafe reference counting, - * no no thread safety is assumed, and the atom becomes thread unsafe too! + * no thread safety is assumed, and the atom becomes thread unsafe too! * * .. note:: ``box`` provides a value based box of type ``T``, this is, we * can think about it as a value-based version of ``std::shared_ptr``. In a @@ -138,7 +138,7 @@ struct gc_atom_impl * ``std::atomic`` interface closely, since it attempts to be a higher level * construction, most similar to Clojure's ``(atom)``. It is remarkable in * particular that, since ``box`` underlying object is immutable, using - * ``atom`` is fully thread-safe in ways that ``std::atmic_shared_ptr`` is + * ``atom`` is fully thread-safe in ways that ``std::atomic_shared_ptr`` is * not. This is so because dereferencing the underlying pointer in a * ``std::atomic_share_ptr`` may require further synchronization, in * particular when invoking non-const methods. diff --git a/immer/box.hpp b/immer/box.hpp index 80b6a724..711ac78f 100644 --- a/immer/box.hpp +++ b/immer/box.hpp @@ -57,6 +57,8 @@ class box {} public: + const holder* impl() const { return impl_; }; + using value_type = T; using memory_policy = MemoryPolicy; @@ -131,24 +133,6 @@ class box /*! Access via pointer member access */ const T* operator->() const { return &get(); } - /*! Comparison. */ - IMMER_NODISCARD bool operator==(detail::exact_t other) const - { - return impl_ == other.value.impl_ || get() == other.value.get(); - } - // Note that the `exact_t` disambiguates comparisons against `T{}` - // directly. In that case we want to use `operator T&` and - // compare directly. We definitely never want to convert a value - // to a box (which causes an allocation) just to compare it. - IMMER_NODISCARD bool operator!=(detail::exact_t other) const - { - return !(*this == other.value); - } - IMMER_NODISCARD bool operator<(detail::exact_t other) const - { - return get() < other.value.get(); - } - /*! * Returns a new box built by applying the `fn` to the underlying * value. @@ -180,6 +164,66 @@ class box } }; +template +IMMER_NODISCARD bool operator==(const box& a, const box& b) +{ + return a.impl() == b.impl() || a.get() == b.get(); +} +template +IMMER_NODISCARD bool operator!=(const box& a, const box& b) +{ + return a.impl() != b.impl() && a.get() != b.get(); +} +template +IMMER_NODISCARD bool operator<(const box& a, const box& b) +{ + return a.impl() != b.impl() && a.get() < b.get(); +} + +template +IMMER_NODISCARD auto operator==(const box& a, T2&& b) + -> std::enable_if_t, std::decay_t>::value, + decltype(a.get() == b)> +{ + return a.get() == b; +} +template +IMMER_NODISCARD auto operator!=(const box& a, T2&& b) + -> std::enable_if_t, std::decay_t>::value, + decltype(a.get() != b)> +{ + return a.get() != b; +} +template +IMMER_NODISCARD auto operator<(const box& a, T2&& b) + -> std::enable_if_t, std::decay_t>::value, + decltype(a.get() < b)> +{ + return a.get() < b; +} + +template +IMMER_NODISCARD auto operator==(T2&& b, const box& a) + -> std::enable_if_t, std::decay_t>::value, + decltype(a.get() == b)> +{ + return a.get() == b; +} +template +IMMER_NODISCARD auto operator!=(T2&& b, const box& a) + -> std::enable_if_t, std::decay_t>::value, + decltype(a.get() != b)> +{ + return a.get() != b; +} +template +IMMER_NODISCARD auto operator<(T2&& b, const box& a) + -> std::enable_if_t, std::decay_t>::value, + decltype(b < a.get())> +{ + return b < a.get(); +} + } // namespace immer namespace std { diff --git a/immer/config.hpp b/immer/config.hpp index c1024fb9..af34e5f1 100644 --- a/immer/config.hpp +++ b/immer/config.hpp @@ -8,6 +8,10 @@ #pragma once +#if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +#define IMMER_HAS_CPP17 1 +#endif + #if defined(__has_cpp_attribute) #if __has_cpp_attribute(nodiscard) #define IMMER_NODISCARD [[nodiscard]] @@ -29,7 +33,7 @@ #define IMMER_CATCH(expr) else #define IMMER_THROW(expr) \ do { \ - assert(!#expr); \ + assert((#expr, false)); \ std::terminate(); \ } while (false) #define IMMER_RETHROW @@ -66,6 +70,10 @@ #define IMMER_DEBUG_PRINT 0 #endif +#ifndef IMMER_DEBUG_STATS +#define IMMER_DEBUG_STATS 0 +#endif + #ifndef IMMER_DEBUG_DEEP_CHECK #define IMMER_DEBUG_DEEP_CHECK 0 #endif @@ -75,6 +83,10 @@ #include #endif +#if IMMER_DEBUG_STATS +#include +#endif + #if IMMER_DEBUG_TRACES #define IMMER_TRACE(...) std::cout << __VA_ARGS__ << std::endl #else diff --git a/immer/detail/arrays/node.hpp b/immer/detail/arrays/node.hpp index 2914bec9..ac521e03 100644 --- a/immer/detail/arrays/node.hpp +++ b/immer/detail/arrays/node.hpp @@ -61,7 +61,7 @@ struct node static void delete_n(node_t* p, size_t sz, size_t cap) { - destroy_n(p->data(), sz); + detail::destroy_n(p->data(), sz); heap::deallocate(sizeof_n(cap), p); } @@ -98,7 +98,7 @@ struct node { auto p = make_n(n); IMMER_TRY { - uninitialized_copy(first, last, p->data()); + detail::uninitialized_copy(first, last, p->data()); return p; } IMMER_CATCH (...) { diff --git a/immer/detail/arrays/with_capacity.hpp b/immer/detail/arrays/with_capacity.hpp index 610a1601..c80f7068 100644 --- a/immer/detail/arrays/with_capacity.hpp +++ b/immer/detail/arrays/with_capacity.hpp @@ -178,17 +178,18 @@ struct with_capacity static size_t recommend_up(size_t sz, size_t cap) { auto max = std::numeric_limits::max(); - return sz <= cap ? cap - : cap >= max / 2 ? max - /* otherwise */ - : std::max(2 * cap, sz); + return sz <= cap ? cap + : cap >= max / 2 ? max + /* otherwise */ + : std::max(2 * cap, sz); } static size_t recommend_down(size_t sz, size_t cap) { - return sz == 0 ? 1 - : sz < cap / 2 ? sz * 2 : - /* otherwise */ cap; + return sz == 0 ? 1 + : sz < cap / 2 ? sz * 2 + : + /* otherwise */ cap; } with_capacity push_back(T value) const @@ -291,6 +292,7 @@ struct with_capacity with_capacity take(std::size_t sz) const { + assert(sz <= size); auto cap = recommend_down(sz, capacity); auto p = node_t::copy_n(cap, ptr, sz); return {p, sz, cap}; @@ -298,8 +300,9 @@ struct with_capacity void take_mut(edit_t e, std::size_t sz) { + assert(sz <= size); if (ptr->can_mutate(e)) { - destroy_n(data() + size, size - sz); + detail::destroy_n(data() + size, size - sz); size = sz; } else { auto cap = recommend_down(sz, capacity); diff --git a/immer/detail/hamts/bits.hpp b/immer/detail/hamts/bits.hpp index 430e2318..0b4b9237 100644 --- a/immer/detail/hamts/bits.hpp +++ b/immer/detail/hamts/bits.hpp @@ -125,6 +125,51 @@ inline count_t popcount(std::uint8_t x) return popcount(static_cast(x)); } +template +class set_bits_range +{ + bitmap_t bitmap; + + class set_bits_iterator + { + bitmap_t bitmap; + + inline static bitmap_t clearlsbit(bitmap_t bitmap) + { + return bitmap & (bitmap - 1); + } + + inline static bitmap_t lsbit(bitmap_t bitmap) + { + return bitmap ^ clearlsbit(bitmap); + } + + public: + set_bits_iterator(bitmap_t bitmap) + : bitmap(bitmap){}; + + set_bits_iterator operator++() + { + bitmap = clearlsbit(bitmap); + return *this; + } + + bool operator!=(set_bits_iterator const& other) const + { + return bitmap != other.bitmap; + } + + bitmap_t operator*() const { return lsbit(bitmap); } + }; + +public: + set_bits_range(bitmap_t bitmap) + : bitmap(bitmap) + {} + set_bits_iterator begin() const { return set_bits_iterator(bitmap); } + set_bits_iterator end() const { return set_bits_iterator(0); } +}; + } // namespace hamts } // namespace detail } // namespace immer diff --git a/immer/detail/hamts/champ.hpp b/immer/detail/hamts/champ.hpp index 30075d6b..30c33877 100644 --- a/immer/detail/hamts/champ.hpp +++ b/immer/detail/hamts/champ.hpp @@ -17,6 +17,107 @@ namespace immer { namespace detail { namespace hamts { +#if IMMER_DEBUG_STATS +struct champ_debug_stats +{ + std::size_t bits = {}; + std::size_t value_size = {}; + std::size_t child_size = sizeof(void*); + + std::size_t inner_node_count = {}; + std::size_t inner_node_w_value_count = {}; + std::size_t inner_node_w_child_count = {}; + std::size_t collision_node_count = {}; + + std::size_t child_count = {}; + std::size_t value_count = {}; + std::size_t collision_count = {}; + + friend champ_debug_stats operator+(champ_debug_stats a, champ_debug_stats b) + { + if (a.bits != b.bits || a.value_size != b.value_size || + a.child_size != b.child_size) + throw std::runtime_error{"accumulating incompatible stats"}; + return { + a.bits, + a.value_size, + a.child_size, + a.inner_node_count + b.inner_node_count, + a.inner_node_w_value_count + b.inner_node_w_value_count, + a.inner_node_w_child_count + b.inner_node_w_child_count, + a.collision_node_count + b.collision_node_count, + a.child_count + b.child_count, + a.value_count + b.value_count, + a.collision_count + b.collision_count, + }; + } + + struct summary + { + double collision_ratio; + + double utilization; + double child_utilization; + double value_utilization; + + double dense_utilization; + double dense_value_utilization; + double dense_child_utilization; + + friend std::ostream& operator<<(std::ostream& os, const summary& s) + { + os << "---\n"; + os << "collisions\n" + << " ratio = " << s.collision_ratio << " %\n"; + os << "utilization\n" + << " total = " << s.utilization << " %\n" + << " children = " << s.child_utilization << " %\n" + << " values = " << s.value_utilization << " %\n"; + os << "utilization (dense)\n" + << " total = " << s.dense_utilization << " %\n" + << " children = " << s.dense_child_utilization << " %\n" + << " values = " << s.dense_value_utilization << " %\n"; + return os; + } + }; + + summary get_summary() const + { + auto m = std::size_t{1} << bits; + + auto collision_ratio = 100. * collision_count / value_count; + + auto capacity = m * inner_node_count; + auto child_utilization = 100. * child_count / capacity; + auto value_utilization = 100. * value_count / capacity; + auto utilization = + 100. * (value_count * value_size + child_count * child_size) / + (capacity * value_size + capacity * child_size); + + auto value_capacity = m * inner_node_w_value_count; + auto child_capacity = m * inner_node_w_child_count; + auto dense_child_utilization = + child_capacity == 0 ? 100. : 100. * child_count / child_capacity; + auto dense_value_utilization = + value_capacity == 0 ? 100. : 100. * value_count / value_capacity; + auto dense_utilization = + value_capacity + child_capacity == 0 + ? 100. + : 100. * (value_count * value_size + child_count * child_size) / + (value_capacity * value_size + + child_capacity * child_size); + + return {collision_ratio, + utilization, + child_utilization, + value_utilization, + dense_utilization, + dense_value_utilization, + dense_child_utilization}; + } +}; +#endif + template ; + using edit_t = typename MemoryPolicy::transience_t::edit; + using owner_t = typename MemoryPolicy::transience_t::owner; using bitmap_t = typename get_bitmap_type::type; static_assert(branches <= sizeof(bitmap_t) * 8, ""); @@ -44,7 +147,8 @@ struct champ champ(node_t* r, size_t sz = 0) : root{r} , size{sz} - {} + { + } champ(const champ& other) : champ{other.root, other.size} @@ -88,6 +192,117 @@ struct champ node_t::delete_deep(root, 0); } + std::size_t do_check_champ(node_t* node, + count_t depth, + size_t path_hash, + size_t hash_mask) const + { + auto result = std::size_t{}; + if (depth < max_depth) { + auto nodemap = node->nodemap(); + if (nodemap) { + auto fst = node->children(); + for (auto idx = std::size_t{}; idx < branches; ++idx) { + if (nodemap & (1 << idx)) { + auto child = *fst++; + result += + do_check_champ(child, + depth + 1, + path_hash | (idx << (B * depth)), + (hash_mask << B) | mask); + } + } + } + auto datamap = node->datamap(); + if (datamap) { + auto fst = node->values(); + for (auto idx = std::size_t{}; idx < branches; ++idx) { + if (datamap & (1 << idx)) { + auto hash = Hash{}(*fst++); + auto check = (hash & hash_mask) == + (path_hash | (idx << (B * depth))); + // assert(check); + result += !!check; + } + } + } + } else { + auto fst = node->collisions(); + auto lst = fst + node->collision_count(); + for (; fst != lst; ++fst) { + auto hash = Hash{}(*fst); + auto check = hash == path_hash; + // assert(check); + result += !!check; + } + } + return result; + } + + // Checks that the hashes of the values correspond with what has actually + // been inserted. If it doesn't it can mean that corruption has happened + // due some value being moved out of the champ when it should have not. + bool check_champ() const + { + auto r = do_check_champ(root, 0, 0, mask); + // assert(r == size); + return r == size; + } + +#if IMMER_DEBUG_STATS + void do_get_debug_stats(champ_debug_stats& stats, + node_t* node, + count_t depth) const + { + if (depth < max_depth) { + ++stats.inner_node_count; + stats.inner_node_w_value_count += node->data_count() > 0; + stats.inner_node_w_child_count += node->children_count() > 0; + stats.value_count += node->data_count(); + stats.child_count += node->children_count(); + auto nodemap = node->nodemap(); + if (nodemap) { + auto fst = node->children(); + auto lst = fst + node->children_count(); + for (; fst != lst; ++fst) + do_get_debug_stats(stats, *fst, depth + 1); + } + } else { + ++stats.collision_node_count; + stats.collision_count += node->collision_count(); + } + } + + champ_debug_stats get_debug_stats() const + { + auto stats = champ_debug_stats{B, sizeof(T)}; + do_get_debug_stats(stats, root, 0); + return stats; + } +#endif + + template + static auto from_initializer_list(std::initializer_list values) + { + auto e = owner_t{}; + auto result = champ{empty()}; + for (auto&& v : values) + result.add_mut(e, v); + return result; + } + + template , bool> = true> + static auto from_range(Iter first, Sent last) + { + auto e = owner_t{}; + auto result = champ{empty()}; + for (; first != last; ++first) + result.add_mut(e, *first); + return result; + } + template void for_each_chunk(Fn&& fn) const { @@ -95,7 +310,8 @@ struct champ } template - void for_each_chunk_traversal(node_t* node, count_t depth, Fn&& fn) const + void + for_each_chunk_traversal(const node_t* node, count_t depth, Fn&& fn) const { if (depth < max_depth) { auto datamap = node->datamap(); @@ -114,6 +330,204 @@ struct champ } } + template + void diff(const champ& new_champ, Differ&& differ) const + { + diff(root, new_champ.root, 0, std::forward(differ)); + } + + template + void diff(const node_t* old_node, + const node_t* new_node, + count_t depth, + Differ&& differ) const + { + if (old_node == new_node) + return; + if (depth < max_depth) { + auto old_nodemap = old_node->nodemap(); + auto new_nodemap = new_node->nodemap(); + auto old_datamap = old_node->datamap(); + auto new_datamap = new_node->datamap(); + auto old_bits = old_nodemap | old_datamap; + auto new_bits = new_nodemap | new_datamap; + auto changes = old_bits ^ new_bits; + + // added bits + for (auto bit : set_bits_range(new_bits & changes)) { + if (new_nodemap & bit) { + auto offset = new_node->children_count(bit); + auto child = new_node->children()[offset]; + for_each_chunk_traversal( + child, + depth + 1, + [&](auto const& begin, auto const& end) { + for (auto it = begin; it != end; it++) + differ.added(*it); + }); + } else if (new_datamap & bit) { + auto offset = new_node->data_count(bit); + auto const& value = new_node->values()[offset]; + differ.added(value); + } + } + + // removed bits + for (auto bit : set_bits_range(old_bits & changes)) { + if (old_nodemap & bit) { + auto offset = old_node->children_count(bit); + auto child = old_node->children()[offset]; + for_each_chunk_traversal( + child, + depth + 1, + [&](auto const& begin, auto const& end) { + for (auto it = begin; it != end; it++) + differ.removed(*it); + }); + } else if (old_datamap & bit) { + auto offset = old_node->data_count(bit); + auto const& value = old_node->values()[offset]; + differ.removed(value); + } + } + + // bits in both nodes + for (auto bit : set_bits_range(old_bits & new_bits)) { + if ((old_nodemap & bit) && (new_nodemap & bit)) { + auto old_offset = old_node->children_count(bit); + auto new_offset = new_node->children_count(bit); + auto old_child = old_node->children()[old_offset]; + auto new_child = new_node->children()[new_offset]; + diff(old_child, new_child, depth + 1, differ); + } else if ((old_datamap & bit) && (new_nodemap & bit)) { + diff_data_node( + old_node, new_node, bit, depth, differ); + } else if ((old_nodemap & bit) && (new_datamap & bit)) { + diff_node_data( + old_node, new_node, bit, depth, differ); + } else if ((old_datamap & bit) && (new_datamap & bit)) { + diff_data_data(old_node, new_node, bit, differ); + } + } + } else { + diff_collisions(old_node, new_node, differ); + } + } + + template + void diff_data_node(const node_t* old_node, + const node_t* new_node, + bitmap_t bit, + count_t depth, + Differ&& differ) const + { + auto old_offset = old_node->data_count(bit); + auto const& old_value = old_node->values()[old_offset]; + auto new_offset = new_node->children_count(bit); + auto new_child = new_node->children()[new_offset]; + + bool found = false; + for_each_chunk_traversal( + new_child, depth + 1, [&](auto const& begin, auto const& end) { + for (auto it = begin; it != end; it++) { + if (Equal{}(old_value, *it)) { + if (!EqualValue{}(old_value, *it)) + differ.changed(old_value, *it); + found = true; + } else { + differ.added(*it); + } + } + }); + if (!found) + differ.removed(old_value); + } + + template + void diff_node_data(const node_t* old_node, + const node_t* const new_node, + bitmap_t bit, + count_t depth, + Differ&& differ) const + { + auto old_offset = old_node->children_count(bit); + auto old_child = old_node->children()[old_offset]; + auto new_offset = new_node->data_count(bit); + auto const& new_value = new_node->values()[new_offset]; + + bool found = false; + for_each_chunk_traversal( + old_child, depth + 1, [&](auto const& begin, auto const& end) { + for (auto it = begin; it != end; it++) { + if (Equal{}(*it, new_value)) { + if (!EqualValue{}(*it, new_value)) + differ.changed(*it, new_value); + found = true; + } else { + differ.removed(*it); + } + } + }); + if (!found) + differ.added(new_value); + } + + template + void diff_data_data(const node_t* old_node, + const node_t* new_node, + bitmap_t bit, + Differ&& differ) const + { + auto old_offset = old_node->data_count(bit); + auto new_offset = new_node->data_count(bit); + auto const& old_value = old_node->values()[old_offset]; + auto const& new_value = new_node->values()[new_offset]; + if (!Equal{}(old_value, new_value)) { + differ.removed(old_value); + differ.added(new_value); + } else { + if (!EqualValue{}(old_value, new_value)) + differ.changed(old_value, new_value); + } + } + + template + void diff_collisions(const node_t* old_node, + const node_t* new_node, + Differ&& differ) const + { + auto old_begin = old_node->collisions(); + auto old_end = old_node->collisions() + old_node->collision_count(); + auto new_begin = new_node->collisions(); + auto new_end = new_node->collisions() + new_node->collision_count(); + // search changes and removals + for (auto old_it = old_begin; old_it != old_end; old_it++) { + bool found = false; + for (auto new_it = new_begin; new_it != new_end; new_it++) { + if (Equal{}(*old_it, *new_it)) { + if (!EqualValue{}(*old_it, *new_it)) + differ.changed(*old_it, *new_it); + found = true; + break; + } + } + if (!found) + differ.removed(*old_it); + } + // search new entries + for (auto new_it = new_begin; new_it != new_end; new_it++) { + bool found = false; + for (auto old_it = old_begin; old_it != old_end; old_it++) { + if (Equal{}(*old_it, *new_it)) { + found = true; + break; + } + } + if (!found) + differ.added(*new_it); + } + } + template decltype(auto) get(const K& k) const { @@ -144,8 +558,13 @@ struct champ return Default{}(); } - std::pair - do_add(node_t* node, T v, hash_t hash, shift_t shift) const + struct add_result + { + node_t* node; + bool added; + }; + + add_result do_add(node_t* node, T v, hash_t hash, shift_t shift) const { assert(node); if (shift == max_shift) { @@ -166,12 +585,12 @@ struct champ auto result = do_add( node->children()[offset], std::move(v), hash, shift + B); IMMER_TRY { - result.first = - node_t::copy_inner_replace(node, offset, result.first); + result.node = + node_t::copy_inner_replace(node, offset, result.node); return result; } IMMER_CATCH (...) { - node_t::delete_deep_shift(result.first, shift + B); + node_t::delete_deep_shift(result.node, shift + B); IMMER_RETHROW; } } else if (node->datamap() & bit) { @@ -206,16 +625,131 @@ struct champ { auto hash = Hash{}(v); auto res = do_add(root, std::move(v), hash, 0); - auto new_size = size + (res.second ? 1 : 0); - return {res.first, new_size}; + auto new_size = size + (res.added ? 1 : 0); + return {res.node, new_size}; + } + + struct add_mut_result + { + node_t* node; + bool added; + bool mutated; + }; + + add_mut_result + do_add_mut(edit_t e, node_t* node, T v, hash_t hash, shift_t shift) const + { + assert(node); + if (shift == max_shift) { + auto fst = node->collisions(); + auto lst = fst + node->collision_count(); + for (; fst != lst; ++fst) + if (Equal{}(*fst, v)) { + if (node->can_mutate(e)) { + *fst = std::move(v); + return {node, false, true}; + } else { + auto r = node_t::copy_collision_replace( + node, fst, std::move(v)); + return {node_t::owned(r, e), false, false}; + } + } + auto mutate = node->can_mutate(e); + auto r = mutate ? node_t::move_collision_insert(node, std::move(v)) + : node_t::copy_collision_insert(node, std::move(v)); + return {node_t::owned(r, e), true, mutate}; + } else { + auto idx = (hash & (mask << shift)) >> shift; + auto bit = bitmap_t{1u} << idx; + if (node->nodemap() & bit) { + auto offset = node->children_count(bit); + auto child = node->children()[offset]; + if (node->can_mutate(e)) { + auto result = + do_add_mut(e, child, std::move(v), hash, shift + B); + node->children()[offset] = result.node; + if (!result.mutated && child->dec()) + node_t::delete_deep_shift(child, shift + B); + return {node, result.added, true}; + } else { + assert(node->children()[offset]); + auto result = do_add(child, std::move(v), hash, shift + B); + IMMER_TRY { + result.node = node_t::copy_inner_replace( + node, offset, result.node); + node_t::owned(result.node, e); + return {result.node, result.added, false}; + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(result.node, shift + B); + IMMER_RETHROW; + } + } + } else if (node->datamap() & bit) { + auto offset = node->data_count(bit); + auto val = node->values() + offset; + if (Equal{}(*val, v)) { + if (node->can_mutate(e)) { + auto vals = node->ensure_mutable_values(e); + vals[offset] = std::move(v); + return {node, false, true}; + } else { + auto r = node_t::copy_inner_replace_value( + node, offset, std::move(v)); + return {node_t::owned_values(r, e), false, false}; + } + } else { + auto mutate = node->can_mutate(e); + auto mutate_values = mutate && node->can_mutate_values(e); + auto hash2 = Hash{}(*val); + auto child = node_t::make_merged_e( + e, + shift + B, + std::move(v), + hash, + mutate_values ? std::move(*val) : *val, + hash2); + IMMER_TRY { + auto r = mutate ? node_t::move_inner_replace_merged( + e, node, bit, offset, child) + : node_t::copy_inner_replace_merged( + node, bit, offset, child); + return {node_t::owned_values_safe(r, e), true, mutate}; + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(child, shift + B); + IMMER_RETHROW; + } + } + } else { + auto mutate = node->can_mutate(e); + auto r = mutate ? node_t::move_inner_insert_value( + e, node, bit, std::move(v)) + : node_t::copy_inner_insert_value( + node, bit, std::move(v)); + return {node_t::owned_values(r, e), true, mutate}; + } + } } + void add_mut(edit_t e, T v) + { + auto hash = Hash{}(v); + auto res = do_add_mut(e, root, std::move(v), hash, 0); + if (!res.mutated && root->dec()) + node_t::delete_deep(root, 0); + root = res.node; + size += res.added ? 1 : 0; + } + + using update_result = add_result; + template - std::pair + update_result do_update(node_t* node, K&& k, Fn&& fn, hash_t hash, shift_t shift) const { if (shift == max_shift) { @@ -223,13 +757,13 @@ struct champ auto lst = fst + node->collision_count(); for (; fst != lst; ++fst) if (Equal{}(*fst, k)) - return { - node_t::copy_collision_replace( - node, - fst, - Combine{}(std::forward(k), - std::forward(fn)(Project{}(*fst)))), - false}; + return {node_t::copy_collision_replace( + node, + fst, + Combine{}(std::forward(k), + std::forward(fn)(Project{}( + detail::as_const(*fst))))), + false}; return {node_t::copy_collision_insert( node, Combine{}(std::forward(k), @@ -247,25 +781,25 @@ struct champ hash, shift + B); IMMER_TRY { - result.first = - node_t::copy_inner_replace(node, offset, result.first); + result.node = + node_t::copy_inner_replace(node, offset, result.node); return result; } IMMER_CATCH (...) { - node_t::delete_deep_shift(result.first, shift + B); + node_t::delete_deep_shift(result.node, shift + B); IMMER_RETHROW; } } else if (node->datamap() & bit) { auto offset = node->data_count(bit); auto val = node->values() + offset; if (Equal{}(*val, k)) - return { - node_t::copy_inner_replace_value( - node, - offset, - Combine{}(std::forward(k), - std::forward(fn)(Project{}(*val)))), - false}; + return {node_t::copy_inner_replace_value( + node, + offset, + Combine{}(std::forward(k), + std::forward(fn)(Project{}( + detail::as_const(*val))))), + false}; else { auto child = node_t::make_merged( shift + B, @@ -305,8 +839,326 @@ struct champ auto hash = Hash{}(k); auto res = do_update( root, k, std::forward(fn), hash, 0); - auto new_size = size + (res.second ? 1 : 0); - return {res.first, new_size}; + auto new_size = size + (res.added ? 1 : 0); + return {res.node, new_size}; + } + + template + node_t* do_update_if_exists( + node_t* node, K&& k, Fn&& fn, hash_t hash, shift_t shift) const + { + if (shift == max_shift) { + auto fst = node->collisions(); + auto lst = fst + node->collision_count(); + for (; fst != lst; ++fst) + if (Equal{}(*fst, k)) + return node_t::copy_collision_replace( + node, + fst, + Combine{}(std::forward(k), + std::forward(fn)( + Project{}(detail::as_const(*fst))))); + return nullptr; + } else { + auto idx = (hash & (mask << shift)) >> shift; + auto bit = bitmap_t{1u} << idx; + if (node->nodemap() & bit) { + auto offset = node->children_count(bit); + auto result = do_update_if_exists( + node->children()[offset], + k, + std::forward(fn), + hash, + shift + B); + IMMER_TRY { + return result ? node_t::copy_inner_replace( + node, offset, result) + : nullptr; + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(result, shift + B); + IMMER_RETHROW; + } + } else if (node->datamap() & bit) { + auto offset = node->data_count(bit); + auto val = node->values() + offset; + if (Equal{}(*val, k)) + return node_t::copy_inner_replace_value( + node, + offset, + Combine{}(std::forward(k), + std::forward(fn)( + Project{}(detail::as_const(*val))))); + else { + return nullptr; + } + } else { + return nullptr; + } + } + } + + template + champ update_if_exists(const K& k, Fn&& fn) const + { + auto hash = Hash{}(k); + auto res = do_update_if_exists( + root, k, std::forward(fn), hash, 0); + if (res) { + return {res, size}; + } else { + return {root->inc(), size}; + }; + } + + using update_mut_result = add_mut_result; + + template + update_mut_result do_update_mut(edit_t e, + node_t* node, + K&& k, + Fn&& fn, + hash_t hash, + shift_t shift) const + { + if (shift == max_shift) { + auto fst = node->collisions(); + auto lst = fst + node->collision_count(); + for (; fst != lst; ++fst) + if (Equal{}(*fst, k)) { + if (node->can_mutate(e)) { + *fst = Combine{}( + std::forward(k), + std::forward(fn)(Project{}(std::move(*fst)))); + return {node, false, true}; + } else { + auto r = node_t::copy_collision_replace( + node, + fst, + Combine{}(std::forward(k), + std::forward(fn)( + Project{}(detail::as_const(*fst))))); + return {node_t::owned(r, e), false, false}; + } + } + auto v = Combine{}(std::forward(k), + std::forward(fn)(Default{}())); + auto mutate = node->can_mutate(e); + auto r = mutate ? node_t::move_collision_insert(node, std::move(v)) + : node_t::copy_collision_insert(node, std::move(v)); + return {node_t::owned(r, e), true, mutate}; + } else { + auto idx = (hash & (mask << shift)) >> shift; + auto bit = bitmap_t{1u} << idx; + if (node->nodemap() & bit) { + auto offset = node->children_count(bit); + auto child = node->children()[offset]; + if (node->can_mutate(e)) { + auto result = do_update_mut( + e, child, k, std::forward(fn), hash, shift + B); + node->children()[offset] = result.node; + if (!result.mutated && child->dec()) + node_t::delete_deep_shift(child, shift + B); + return {node, result.added, true}; + } else { + auto result = do_update( + child, k, std::forward(fn), hash, shift + B); + IMMER_TRY { + result.node = node_t::copy_inner_replace( + node, offset, result.node); + node_t::owned(result.node, e); + return {result.node, result.added, false}; + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(result.node, shift + B); + IMMER_RETHROW; + } + } + } else if (node->datamap() & bit) { + auto offset = node->data_count(bit); + auto val = node->values() + offset; + if (Equal{}(*val, k)) { + if (node->can_mutate(e)) { + auto vals = node->ensure_mutable_values(e); + vals[offset] = Combine{}(std::forward(k), + std::forward(fn)(Project{}( + std::move(vals[offset])))); + return {node, false, true}; + } else { + auto r = node_t::copy_inner_replace_value( + node, + offset, + Combine{}(std::forward(k), + std::forward(fn)( + Project{}(detail::as_const(*val))))); + return {node_t::owned_values(r, e), false, false}; + } + } else { + auto mutate = node->can_mutate(e); + auto mutate_values = mutate && node->can_mutate_values(e); + auto hash2 = Hash{}(*val); + auto child = node_t::make_merged_e( + e, + shift + B, + Combine{}(std::forward(k), + std::forward(fn)(Default{}())), + hash, + mutate_values ? std::move(*val) : *val, + hash2); + IMMER_TRY { + auto r = mutate ? node_t::move_inner_replace_merged( + e, node, bit, offset, child) + : node_t::copy_inner_replace_merged( + node, bit, offset, child); + return {node_t::owned_values_safe(r, e), true, mutate}; + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(child, shift + B); + IMMER_RETHROW; + } + } + } else { + auto mutate = node->can_mutate(e); + auto v = Combine{}(std::forward(k), + std::forward(fn)(Default{}())); + auto r = mutate ? node_t::move_inner_insert_value( + e, node, bit, std::move(v)) + : node_t::copy_inner_insert_value( + node, bit, std::move(v)); + return {node_t::owned_values(r, e), true, mutate}; + } + } + } + + template + void update_mut(edit_t e, const K& k, Fn&& fn) + { + auto hash = Hash{}(k); + auto res = do_update_mut( + e, root, k, std::forward(fn), hash, 0); + if (!res.mutated && root->dec()) + node_t::delete_deep(root, 0); + root = res.node; + size += res.added ? 1 : 0; + } + + struct update_if_exists_mut_result + { + node_t* node; + bool mutated; + }; + + template + update_if_exists_mut_result do_update_if_exists_mut(edit_t e, + node_t* node, + K&& k, + Fn&& fn, + hash_t hash, + shift_t shift) const + { + if (shift == max_shift) { + auto fst = node->collisions(); + auto lst = fst + node->collision_count(); + for (; fst != lst; ++fst) + if (Equal{}(*fst, k)) { + if (node->can_mutate(e)) { + *fst = Combine{}( + std::forward(k), + std::forward(fn)(Project{}(std::move(*fst)))); + return {node, true}; + } else { + auto r = node_t::copy_collision_replace( + node, + fst, + Combine{}(std::forward(k), + std::forward(fn)( + Project{}(detail::as_const(*fst))))); + return {node_t::owned(r, e), false}; + } + } + return {nullptr, false}; + } else { + auto idx = (hash & (mask << shift)) >> shift; + auto bit = bitmap_t{1u} << idx; + if (node->nodemap() & bit) { + auto offset = node->children_count(bit); + auto child = node->children()[offset]; + if (node->can_mutate(e)) { + auto result = do_update_if_exists_mut( + e, child, k, std::forward(fn), hash, shift + B); + if (result.node) { + node->children()[offset] = result.node; + if (!result.mutated && child->dec()) + node_t::delete_deep_shift(child, shift + B); + return {node, true}; + } else { + return {nullptr, false}; + } + } else { + auto result = do_update_if_exists( + child, k, std::forward(fn), hash, shift + B); + IMMER_TRY { + if (result) { + result = node_t::copy_inner_replace( + node, offset, result); + node_t::owned(result, e); + return {result, false}; + } else { + return {nullptr, false}; + } + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(result, shift + B); + IMMER_RETHROW; + } + } + } else if (node->datamap() & bit) { + auto offset = node->data_count(bit); + auto val = node->values() + offset; + if (Equal{}(*val, k)) { + if (node->can_mutate(e)) { + auto vals = node->ensure_mutable_values(e); + vals[offset] = Combine{}(std::forward(k), + std::forward(fn)(Project{}( + std::move(vals[offset])))); + return {node, true}; + } else { + auto r = node_t::copy_inner_replace_value( + node, + offset, + Combine{}(std::forward(k), + std::forward(fn)( + Project{}(detail::as_const(*val))))); + return {node_t::owned_values(r, e), false}; + } + } else { + return {nullptr, false}; + } + } else { + return {nullptr, false}; + } + } + } + + template + void update_if_exists_mut(edit_t e, const K& k, Fn&& fn) + { + auto hash = Hash{}(k); + auto res = do_update_if_exists_mut( + e, root, k, std::forward(fn), hash, 0); + if (res.node) { + if (!res.mutated && root->dec()) + node_t::delete_deep(root, 0); + root = res.node; + } } // basically: @@ -356,7 +1208,20 @@ struct champ return node->collision_count() > 2 ? node_t::copy_collision_remove(node, cur) : sub_result{fst + (cur == fst)}; +#if !defined(_MSC_VER) +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif +#endif + // Apparently GCC is generating this warning sometimes when + // compiling the benchmarks. It makes however no sense at all. return {}; +#if !defined(_MSC_VER) +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +#endif } else { auto idx = (hash & (mask << shift)) >> shift; auto bit = bitmap_t{1u} << idx; @@ -422,6 +1287,215 @@ struct champ } } + struct sub_result_mut + { + using kind_t = typename sub_result::kind_t; + using data_t = typename sub_result::data_t; + + kind_t kind; + data_t data; + bool owned; + bool mutated; + + sub_result_mut(sub_result a) + : kind{a.kind} + , data{a.data} + , owned{false} + , mutated{false} + { + } + sub_result_mut(sub_result a, bool m) + : kind{a.kind} + , data{a.data} + , owned{false} + , mutated{m} + { + } + sub_result_mut() + : kind{kind_t::nothing} + , mutated{false} {}; + sub_result_mut(T* x, bool m) + : kind{kind_t::singleton} + , owned{m} + , mutated{m} + { + data.singleton = x; + }; + sub_result_mut(T* x, bool o, bool m) + : kind{kind_t::singleton} + , owned{o} + , mutated{m} + { + data.singleton = x; + }; + sub_result_mut(node_t* x, bool m) + : kind{kind_t::tree} + , owned{false} + , mutated{m} + { + data.tree = x; + }; + }; + + template + sub_result_mut do_sub_mut(edit_t e, + node_t* node, + const K& k, + hash_t hash, + shift_t shift, + void* store) const + { + auto mutate = node->can_mutate(e); + if (shift == max_shift) { + auto fst = node->collisions(); + auto lst = fst + node->collision_count(); + for (auto cur = fst; cur != lst; ++cur) { + if (Equal{}(*cur, k)) { + if (node->collision_count() <= 2) { + if (mutate) { + auto r = new (store) + T{std::move(node->collisions()[cur == fst])}; + node_t::delete_collision(node); + return sub_result_mut{r, true}; + } else { + return sub_result_mut{fst + (cur == fst), false}; + } + } else { + auto r = mutate + ? node_t::move_collision_remove(node, cur) + : node_t::copy_collision_remove(node, cur); + return {node_t::owned(r, e), mutate}; + } + } + } + return {}; + } else { + auto idx = (hash & (mask << shift)) >> shift; + auto bit = bitmap_t{1u} << idx; + if (node->nodemap() & bit) { + auto offset = node->children_count(bit); + auto children = node->children(); + auto child = children[offset]; + auto result = + mutate ? do_sub_mut(e, child, k, hash, shift + B, store) + : do_sub(child, k, hash, shift + B); + switch (result.kind) { + case sub_result::nothing: + return {}; + case sub_result::singleton: + if (node->datamap() == 0 && node->children_count() == 1 && + shift > 0) { + if (mutate) { + node_t::delete_inner(node); + if (!result.mutated && child->dec()) + node_t::delete_deep_shift(child, shift + B); + } + return {result.data.singleton, result.owned, mutate}; + } else { + auto r = + mutate ? node_t::move_inner_replace_inline( + e, + node, + bit, + offset, + result.owned + ? std::move(*result.data.singleton) + : *result.data.singleton) + : node_t::copy_inner_replace_inline( + node, + bit, + offset, + *result.data.singleton); + if (result.owned) + detail::destroy_at(result.data.singleton); + if (!result.mutated && mutate && child->dec()) + node_t::delete_deep_shift(child, shift + B); + return {node_t::owned_values(r, e), mutate}; + } + case sub_result::tree: + if (mutate) { + children[offset] = result.data.tree; + if (!result.mutated && child->dec()) + node_t::delete_deep_shift(child, shift + B); + return {node, true}; + } else { + IMMER_TRY { + auto r = node_t::copy_inner_replace( + node, offset, result.data.tree); + return {node_t::owned(r, e), false}; + } + IMMER_CATCH (...) { + node_t::delete_deep_shift(result.data.tree, + shift + B); + IMMER_RETHROW; + } + } + } + } else if (node->datamap() & bit) { + auto offset = node->data_count(bit); + auto val = node->values() + offset; + auto mutate_values = mutate && node->can_mutate_values(e); + if (Equal{}(*val, k)) { + auto nv = node->data_count(); + if (node->nodemap() || nv > 2) { + auto r = mutate ? node_t::move_inner_remove_value( + e, node, bit, offset) + : node_t::copy_inner_remove_value( + node, bit, offset); + return {node_t::owned_values_safe(r, e), mutate}; + } else if (nv == 2) { + if (shift > 0) { + if (mutate_values) { + auto r = new (store) + T{std::move(node->values()[!offset])}; + node_t::delete_inner(node); + return {r, true}; + } else { + return {node->values() + !offset, false}; + } + } else { + auto& v = node->values()[!offset]; + auto r = node_t::make_inner_n( + 0, + node->datamap() & ~bit, + mutate_values ? std::move(v) : v); + assert(!node->nodemap()); + if (mutate) + node_t::delete_inner(node); + return {node_t::owned_values(r, e), mutate}; + } + } else { + assert(shift == 0); + if (mutate) + node_t::delete_inner(node); + return {empty(), mutate}; + } + } + } + return {}; + } + } + + template + void sub_mut(edit_t e, const K& k) + { + auto store = aligned_storage_for{}; + auto hash = Hash{}(k); + auto res = do_sub_mut(e, root, k, hash, 0, &store); + switch (res.kind) { + case sub_result::nothing: + break; + case sub_result::tree: + if (!res.mutated && root->dec()) + node_t::delete_deep(root, 0); + root = res.data.tree; + --size; + break; + default: + IMMER_UNREACHABLE; + } + } + template bool equals(const champ& other) const { diff --git a/immer/detail/hamts/champ_iterator.hpp b/immer/detail/hamts/champ_iterator.hpp index 594ad750..22101f9d 100644 --- a/immer/detail/hamts/champ_iterator.hpp +++ b/immer/detail/hamts/champ_iterator.hpp @@ -53,6 +53,8 @@ struct champ_iterator using tree_t = champ; using node_t = typename tree_t::node_t; + champ_iterator() = default; + struct end_t {}; @@ -96,6 +98,7 @@ struct champ_iterator T* cur_; T* end_; count_t depth_; + count_t cur_off_; node_t* const* path_[max_depth + 1] = { 0, }; diff --git a/immer/detail/hamts/node.hpp b/immer/detail/hamts/node.hpp index e2607f01..7f7dc8b1 100644 --- a/immer/detail/hamts/node.hpp +++ b/immer/detail/hamts/node.hpp @@ -20,6 +20,11 @@ namespace immer { namespace detail { namespace hamts { +// For C++14 support. +// Calling the destructor inline breaks MSVC in some obscure +// corner cases. +template constexpr void destroy_at(T* p) { p->~T(); } + template buffer; }; - using values_t = combine_standard_layout_t; + using values_t = combine_standard_layout_t; struct inner_t { @@ -80,7 +85,7 @@ struct node data_t data; }; - using impl_t = combine_standard_layout_t; + using impl_t = combine_standard_layout_t; impl_t impl; @@ -193,6 +198,10 @@ struct node } static const ownee_t& ownee(const values_t* x) { return get(*x); } static ownee_t& ownee(values_t* x) { return get(*x); } + static bool can_mutate(values_t* x, edit_t e) + { + return refs(x).unique() || ownee(x).can_mutate(e); + } static refs_t& refs(const node_t* x) { @@ -204,6 +213,15 @@ struct node } static ownee_t& ownee(node_t* x) { return get(x->impl); } + bool can_mutate(edit_t e) const + { + return refs(this).unique() || ownee(this).can_mutate(e); + } + bool can_mutate_values(edit_t e) const + { + return can_mutate(impl.d.data.inner.values, e); + } + static node_t* make_inner_n(count_t n) { assert(n <= branches); @@ -284,7 +302,7 @@ struct node new (vp + 1) T{std::move(x2)}; } IMMER_CATCH (...) { - vp->~T(); + immer::detail::hamts::destroy_at(vp); IMMER_RETHROW; } } @@ -337,6 +355,32 @@ struct node return p; } + T* ensure_mutable_values(edit_t e) + { + assert(can_mutate(e)); + auto old = impl.d.data.inner.values; + if (node_t::can_mutate(old, e)) + return values(); + else { + auto nv = data_count(); + auto nxt = new (heap::allocate(sizeof_values_n(nv))) values_t{}; + auto dst = (T*) &nxt->d.buffer; + auto src = values(); + ownee(nxt) = e; + IMMER_TRY { + detail::uninitialized_copy(src, src + nv, dst); + } + IMMER_CATCH (...) { + deallocate_values(nxt, nv); + IMMER_RETHROW; + } + impl.d.data.inner.values = nxt; + if (refs(old).dec()) + delete_values(old, nv); + return dst; + } + } + static node_t* copy_collision_insert(node_t* src, T v) { IMMER_ASSERT_TAGGED(src->kind() == kind_t::collision); @@ -347,7 +391,31 @@ struct node IMMER_TRY { new (dstp) T{std::move(v)}; IMMER_TRY { - std::uninitialized_copy(srcp, srcp + n, dstp + 1); + detail::uninitialized_copy(srcp, srcp + n, dstp + 1); + } + IMMER_CATCH (...) { + dstp->~T(); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_collision(dst, n + 1); + IMMER_RETHROW; + } + return dst; + } + + static node_t* move_collision_insert(node_t* src, T v) + { + IMMER_ASSERT_TAGGED(src->kind() == kind_t::collision); + auto n = src->collision_count(); + auto dst = make_collision_n(n + 1); + auto srcp = src->collisions(); + auto dstp = dst->collisions(); + IMMER_TRY { + new (dstp) T{std::move(v)}; + IMMER_TRY { + detail::uninitialized_move(srcp, srcp + n, dstp + 1); } IMMER_CATCH (...) { dstp->~T(); @@ -358,6 +426,7 @@ struct node deallocate_collision(dst, n + 1); IMMER_RETHROW; } + delete_collision(src); return dst; } @@ -370,12 +439,37 @@ struct node auto srcp = src->collisions(); auto dstp = dst->collisions(); IMMER_TRY { - dstp = std::uninitialized_copy(srcp, v, dstp); + dstp = detail::uninitialized_copy(srcp, v, dstp); + IMMER_TRY { + detail::uninitialized_copy(v + 1, srcp + n, dstp); + } + IMMER_CATCH (...) { + detail::destroy(dst->collisions(), dstp); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_collision(dst, n - 1); + IMMER_RETHROW; + } + return dst; + } + + static node_t* move_collision_remove(node_t* src, T* v) + { + IMMER_ASSERT_TAGGED(src->kind() == kind_t::collision); + assert(src->collision_count() > 1); + auto n = src->collision_count(); + auto dst = make_collision_n(n - 1); + auto srcp = src->collisions(); + auto dstp = dst->collisions(); + IMMER_TRY { + dstp = detail::uninitialized_move(srcp, v, dstp); IMMER_TRY { - std::uninitialized_copy(v + 1, srcp + n, dstp); + detail::uninitialized_move(v + 1, srcp + n, dstp); } IMMER_CATCH (...) { - destroy(dst->collisions(), dstp); + detail::destroy(dst->collisions(), dstp); IMMER_RETHROW; } } @@ -383,6 +477,7 @@ struct node deallocate_collision(dst, n - 1); IMMER_RETHROW; } + delete_collision(src); return dst; } @@ -397,12 +492,12 @@ struct node IMMER_TRY { new (dstp) T{std::move(v)}; IMMER_TRY { - dstp = std::uninitialized_copy(srcp, pos, dstp + 1); + dstp = detail::uninitialized_copy(srcp, pos, dstp + 1); IMMER_TRY { - std::uninitialized_copy(pos + 1, srcp + n, dstp); + detail::uninitialized_copy(pos + 1, srcp + n, dstp); } IMMER_CATCH (...) { - destroy(dst->collisions(), dstp); + detail::destroy(dst->collisions(), dstp); IMMER_RETHROW; } } @@ -428,13 +523,34 @@ struct node auto dstp = dst->children(); dst->impl.d.data.inner.datamap = src->datamap(); dst->impl.d.data.inner.nodemap = src->nodemap(); - std::uninitialized_copy(srcp, srcp + n, dstp); - inc_nodes(srcp, n); - srcp[offset]->dec_unsafe(); + std::copy(srcp, srcp + n, dstp); + inc_nodes(srcp, offset); + inc_nodes(srcp + offset + 1, n - offset - 1); dstp[offset] = child; return dst; } + static node_t* owned(node_t* n, edit_t e) + { + ownee(n) = e; + return n; + } + + static node_t* owned_values(node_t* n, edit_t e) + { + ownee(n) = e; + ownee(n->impl.d.data.inner.values) = e; + return n; + } + + static node_t* owned_values_safe(node_t* n, edit_t e) + { + ownee(n) = e; + if (n->impl.d.data.inner.values) + ownee(n->impl.d.data.inner.values) = e; + return n; + } + static node_t* copy_inner_replace_value(node_t* src, count_t offset, T v) { IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); @@ -445,13 +561,13 @@ struct node dst->impl.d.data.inner.datamap = src->datamap(); dst->impl.d.data.inner.nodemap = src->nodemap(); IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src->values(), src->values() + nv, dst->values()); IMMER_TRY { dst->values()[offset] = std::move(v); } IMMER_CATCH (...) { - destroy_n(dst->values(), nv); + detail::destroy_n(dst->values(), nv); IMMER_RETHROW; } } @@ -460,8 +576,7 @@ struct node IMMER_RETHROW; } inc_nodes(src->children(), n); - std::uninitialized_copy( - src->children(), src->children() + n, dst->children()); + std::copy(src->children(), src->children() + n, dst->children()); return dst; } @@ -482,15 +597,15 @@ struct node dst->impl.d.data.inner.nodemap = src->nodemap() | bit; if (nv > 1) { IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src->values(), src->values() + voffset, dst->values()); IMMER_TRY { - std::uninitialized_copy(src->values() + voffset + 1, - src->values() + nv, - dst->values() + voffset); + detail::uninitialized_copy(src->values() + voffset + 1, + src->values() + nv, + dst->values() + voffset); } IMMER_CATCH (...) { - destroy_n(dst->values(), voffset); + detail::destroy_n(dst->values(), voffset); IMMER_RETHROW; } } @@ -500,12 +615,63 @@ struct node } } inc_nodes(src->children(), n); - std::uninitialized_copy( - src->children(), src->children() + noffset, dst->children()); - std::uninitialized_copy(src->children() + noffset, - src->children() + n, - dst->children() + noffset + 1); + std::copy(src->children(), src->children() + noffset, dst->children()); + std::copy(src->children() + noffset, + src->children() + n, + dst->children() + noffset + 1); + dst->children()[noffset] = node; + return dst; + } + + static node_t* move_inner_replace_merged( + edit_t e, node_t* src, bitmap_t bit, count_t voffset, node_t* node) + { + IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); + assert(!(src->nodemap() & bit)); + assert(src->datamap() & bit); + assert(voffset == src->data_count(bit)); + auto n = src->children_count(); + auto nv = src->data_count(); + auto dst = make_inner_n(n + 1, nv - 1); + auto noffset = src->children_count(bit); + dst->impl.d.data.inner.datamap = src->datamap() & ~bit; + dst->impl.d.data.inner.nodemap = src->nodemap() | bit; + if (nv > 1) { + auto mutate_values = can_mutate(src->impl.d.data.inner.values, e); + IMMER_TRY { + if (mutate_values) + detail::uninitialized_move( + src->values(), src->values() + voffset, dst->values()); + else + detail::uninitialized_copy( + src->values(), src->values() + voffset, dst->values()); + IMMER_TRY { + if (mutate_values) + detail::uninitialized_move(src->values() + voffset + 1, + src->values() + nv, + dst->values() + voffset); + else + detail::uninitialized_copy(src->values() + voffset + 1, + src->values() + nv, + dst->values() + voffset); + } + IMMER_CATCH (...) { + detail::destroy_n(dst->values(), voffset); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_inner(dst, n + 1, nv - 1); + IMMER_RETHROW; + } + } + // inc_nodes(src->children(), n); + std::copy(src->children(), src->children() + noffset, dst->children()); + std::copy(src->children() + noffset, + src->children() + n, + dst->children() + noffset + 1); dst->children()[noffset] = node; + delete_inner(src); return dst; } @@ -526,15 +692,15 @@ struct node dst->impl.d.data.inner.datamap = src->datamap() | bit; IMMER_TRY { if (nv) - std::uninitialized_copy( + detail::uninitialized_copy( src->values(), src->values() + voffset, dst->values()); IMMER_TRY { new (dst->values() + voffset) T{std::move(value)}; IMMER_TRY { if (nv) - std::uninitialized_copy(src->values() + voffset, - src->values() + nv, - dst->values() + voffset + 1); + detail::uninitialized_copy(src->values() + voffset, + src->values() + nv, + dst->values() + voffset + 1); } IMMER_CATCH (...) { dst->values()[voffset].~T(); @@ -542,7 +708,7 @@ struct node } } IMMER_CATCH (...) { - destroy_n(dst->values(), voffset); + detail::destroy_n(dst->values(), voffset); IMMER_RETHROW; } } @@ -550,13 +716,74 @@ struct node deallocate_inner(dst, n - 1, nv + 1); IMMER_RETHROW; } - inc_nodes(src->children(), n); - src->children()[noffset]->dec_unsafe(); - std::uninitialized_copy( - src->children(), src->children() + noffset, dst->children()); - std::uninitialized_copy(src->children() + noffset + 1, - src->children() + n, - dst->children() + noffset); + inc_nodes(src->children(), noffset); + inc_nodes(src->children() + noffset + 1, n - noffset - 1); + std::copy(src->children(), src->children() + noffset, dst->children()); + std::copy(src->children() + noffset + 1, + src->children() + n, + dst->children() + noffset); + return dst; + } + + static node_t* move_inner_replace_inline( + edit_t e, node_t* src, bitmap_t bit, count_t noffset, T value) + { + IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); + assert(!(src->datamap() & bit)); + assert(src->nodemap() & bit); + assert(noffset == src->children_count(bit)); + auto n = src->children_count(); + auto nv = src->data_count(); + auto dst = make_inner_n(n - 1, nv + 1); + auto voffset = src->data_count(bit); + dst->impl.d.data.inner.nodemap = src->nodemap() & ~bit; + dst->impl.d.data.inner.datamap = src->datamap() | bit; + IMMER_TRY { + auto mutate_values = + nv && can_mutate(src->impl.d.data.inner.values, e); + if (nv) { + if (mutate_values) + detail::uninitialized_move( + src->values(), src->values() + voffset, dst->values()); + else + detail::uninitialized_copy( + src->values(), src->values() + voffset, dst->values()); + } + IMMER_TRY { + new (dst->values() + voffset) T{std::move(value)}; + IMMER_TRY { + if (nv) { + if (mutate_values) + detail::uninitialized_move(src->values() + voffset, + src->values() + nv, + dst->values() + voffset + + 1); + else + detail::uninitialized_copy(src->values() + voffset, + src->values() + nv, + dst->values() + voffset + + 1); + } + } + IMMER_CATCH (...) { + dst->values()[voffset].~T(); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + detail::destroy_n(dst->values(), voffset); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_inner(dst, n - 1, nv + 1); + IMMER_RETHROW; + } + std::copy(src->children(), src->children() + noffset, dst->children()); + std::copy(src->children() + noffset + 1, + src->children() + n, + dst->children() + noffset); + delete_inner(src); return dst; } @@ -574,15 +801,15 @@ struct node dst->impl.d.data.inner.nodemap = src->nodemap(); if (nv > 1) { IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src->values(), src->values() + voffset, dst->values()); IMMER_TRY { - std::uninitialized_copy(src->values() + voffset + 1, - src->values() + nv, - dst->values() + voffset); + detail::uninitialized_copy(src->values() + voffset + 1, + src->values() + nv, + dst->values() + voffset); } IMMER_CATCH (...) { - destroy_n(dst->values(), voffset); + detail::destroy_n(dst->values(), voffset); IMMER_RETHROW; } } @@ -592,8 +819,66 @@ struct node } } inc_nodes(src->children(), n); - std::uninitialized_copy( - src->children(), src->children() + n, dst->children()); + std::copy(src->children(), src->children() + n, dst->children()); + return dst; + } + + static node_t* move_inner_remove_value(edit_t e, + node_t* src, + bitmap_t bit, + count_t voffset) + { + IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); + assert(!(src->nodemap() & bit)); + assert(src->datamap() & bit); + assert(voffset == src->data_count(bit)); + auto n = src->children_count(); + auto nv = src->data_count(); + auto dst = make_inner_n(n, nv - 1); + dst->impl.d.data.inner.datamap = src->datamap() & ~bit; + dst->impl.d.data.inner.nodemap = src->nodemap(); + if (nv > 1) { + auto mutate_values = can_mutate(src->impl.d.data.inner.values, e); + if (mutate_values) { + IMMER_TRY { + detail::uninitialized_move( + src->values(), src->values() + voffset, dst->values()); + IMMER_TRY { + detail::uninitialized_move(src->values() + voffset + 1, + src->values() + nv, + dst->values() + voffset); + } + IMMER_CATCH (...) { + detail::destroy_n(dst->values(), voffset); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_inner(dst, n, nv - 1); + IMMER_RETHROW; + } + } else { + IMMER_TRY { + detail::uninitialized_copy( + src->values(), src->values() + voffset, dst->values()); + IMMER_TRY { + detail::uninitialized_copy(src->values() + voffset + 1, + src->values() + nv, + dst->values() + voffset); + } + IMMER_CATCH (...) { + detail::destroy_n(dst->values(), voffset); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_inner(dst, n, nv - 1); + IMMER_RETHROW; + } + } + } + std::copy(src->children(), src->children() + n, dst->children()); + delete_inner(src); return dst; } @@ -608,15 +893,15 @@ struct node dst->impl.d.data.inner.nodemap = src->nodemap(); IMMER_TRY { if (nv) - std::uninitialized_copy( + detail::uninitialized_copy( src->values(), src->values() + offset, dst->values()); IMMER_TRY { new (dst->values() + offset) T{std::move(v)}; IMMER_TRY { if (nv) - std::uninitialized_copy(src->values() + offset, - src->values() + nv, - dst->values() + offset + 1); + detail::uninitialized_copy(src->values() + offset, + src->values() + nv, + dst->values() + offset + 1); } IMMER_CATCH (...) { dst->values()[offset].~T(); @@ -624,7 +909,7 @@ struct node } } IMMER_CATCH (...) { - destroy_n(dst->values(), offset); + detail::destroy_n(dst->values(), offset); IMMER_RETHROW; } } @@ -633,8 +918,63 @@ struct node IMMER_RETHROW; } inc_nodes(src->children(), n); - std::uninitialized_copy( - src->children(), src->children() + n, dst->children()); + std::copy(src->children(), src->children() + n, dst->children()); + return dst; + } + + static node_t* + move_inner_insert_value(edit_t e, node_t* src, bitmap_t bit, T v) + { + IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); + auto n = src->children_count(); + auto nv = src->data_count(); + auto offset = src->data_count(bit); + auto dst = make_inner_n(n, nv + 1); + dst->impl.d.data.inner.datamap = src->datamap() | bit; + dst->impl.d.data.inner.nodemap = src->nodemap(); + IMMER_TRY { + auto mutate_values = + nv && can_mutate(src->impl.d.data.inner.values, e); + if (nv) { + if (mutate_values) + detail::uninitialized_move( + src->values(), src->values() + offset, dst->values()); + else + detail::uninitialized_copy( + src->values(), src->values() + offset, dst->values()); + } + IMMER_TRY { + new (dst->values() + offset) T{std::move(v)}; + IMMER_TRY { + if (nv) { + if (mutate_values) + detail::uninitialized_move(src->values() + offset, + src->values() + nv, + dst->values() + offset + + 1); + else + detail::uninitialized_copy(src->values() + offset, + src->values() + nv, + dst->values() + offset + + 1); + } + } + IMMER_CATCH (...) { + dst->values()[offset].~T(); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + detail::destroy_n(dst->values(), offset); + IMMER_RETHROW; + } + } + IMMER_CATCH (...) { + deallocate_inner(dst, n, nv + 1); + IMMER_RETHROW; + } + std::copy(src->children(), src->children() + n, dst->children()); + delete_inner(src); return dst; } @@ -648,7 +988,8 @@ struct node auto merged = make_merged( shift + B, std::move(v1), hash1, std::move(v2), hash2); IMMER_TRY { - return make_inner_n(1, idx1 >> shift, merged); + return make_inner_n( + 1, static_cast(idx1 >> shift), merged); } IMMER_CATCH (...) { delete_deep_shift(merged, shift + B); @@ -656,9 +997,9 @@ struct node } } else { return make_inner_n(0, - idx1 >> shift, + static_cast(idx1 >> shift), std::move(v1), - idx2 >> shift, + static_cast(idx2 >> shift), std::move(v2)); } } else { @@ -666,6 +1007,38 @@ struct node } } + static node_t* make_merged_e( + edit_t e, shift_t shift, T v1, hash_t hash1, T v2, hash_t hash2) + { + if (shift < max_shift) { + auto idx1 = hash1 & (mask << shift); + auto idx2 = hash2 & (mask << shift); + if (idx1 == idx2) { + auto merged = make_merged_e( + e, shift + B, std::move(v1), hash1, std::move(v2), hash2); + IMMER_TRY { + return owned( + make_inner_n( + 1, static_cast(idx1 >> shift), merged), + e); + } + IMMER_CATCH (...) { + delete_deep_shift(merged, shift + B); + IMMER_RETHROW; + } + } else { + auto r = make_inner_n(0, + static_cast(idx1 >> shift), + std::move(v1), + static_cast(idx2 >> shift), + std::move(v2)); + return owned_values(r, e); + } + } else { + return owned(make_collision(std::move(v1), std::move(v2)), e); + } + } + node_t* inc() { refs(this).inc(); @@ -679,7 +1052,6 @@ struct node } bool dec() const { return refs(this).dec(); } - void dec_unsafe() const { refs(this).dec_unsafe(); } static void inc_nodes(node_t** p, count_t n) { @@ -690,6 +1062,7 @@ struct node static void delete_values(values_t* p, count_t n) { assert(p); + detail::destroy_n((T*) &p->d.buffer, n); deallocate_values(p, n); } @@ -708,6 +1081,7 @@ struct node assert(p); IMMER_ASSERT_TAGGED(p->kind() == kind_t::collision); auto n = p->collision_count(); + detail::destroy_n(p->collisions(), n); deallocate_collision(p, n); } @@ -741,13 +1115,11 @@ struct node static void deallocate_values(values_t* p, count_t n) { - destroy_n((T*) &p->d.buffer, n); heap::deallocate(node_t::sizeof_values_n(n), p); } static void deallocate_collision(node_t* p, count_t n) { - destroy_n(p->collisions(), n); heap::deallocate(node_t::sizeof_collision_n(n), p); } diff --git a/immer/detail/iterator_facade.hpp b/immer/detail/iterator_facade.hpp index ffc23794..1d5578c8 100644 --- a/immer/detail/iterator_facade.hpp +++ b/immer/detail/iterator_facade.hpp @@ -82,19 +82,6 @@ class iterator_facade std::is_base_of::value; - class reference_proxy - { - friend iterator_facade; - DerivedT iter_; - - reference_proxy(DerivedT iter) - : iter_{std::move(iter)} - {} - - public: - operator ReferenceT() const { return *iter_; } - }; - const DerivedT& derived() const { static_assert(std::is_base_of::value, @@ -111,19 +98,19 @@ class iterator_facade public: ReferenceT operator*() const { return access_t::dereference(derived()); } PointerT operator->() const { return &access_t::dereference(derived()); } - reference_proxy operator[](DifferenceTypeT n) const + ReferenceT operator[](DifferenceTypeT n) const { static_assert(is_random_access, ""); - return derived() + n; + return *(derived() + n); } - bool operator==(const DerivedT& rhs) const + friend bool operator==(const DerivedT& a, const DerivedT& b) { - return access_t::equal(derived(), rhs); + return access_t::equal(a, b); } - bool operator!=(const DerivedT& rhs) const + friend bool operator!=(const DerivedT& a, const DerivedT& b) { - return !access_t::equal(derived(), rhs); + return !access_t::equal(a, b); } DerivedT& operator++() @@ -180,31 +167,31 @@ class iterator_facade auto tmp = derived(); return tmp -= n; } - DifferenceTypeT operator-(const DerivedT& rhs) const + friend DifferenceTypeT operator-(const DerivedT& a, const DerivedT& b) { static_assert(is_random_access, ""); - return access_t::distance_to(rhs, derived()); + return access_t::distance_to(b, a); } - bool operator<(const DerivedT& rhs) const + friend bool operator<(const DerivedT& a, const DerivedT& b) { static_assert(is_random_access, ""); - return access_t::distance_to(derived(), rhs) > 0; + return access_t::distance_to(a, b) > 0; } - bool operator<=(const DerivedT& rhs) const + friend bool operator<=(const DerivedT& a, const DerivedT& b) { static_assert(is_random_access, ""); - return access_t::distance_to(derived(), rhs) >= 0; + return access_t::distance_to(a, b) >= 0; } - bool operator>(const DerivedT& rhs) const + friend bool operator>(const DerivedT& a, const DerivedT& b) { static_assert(is_random_access, ""); - return access_t::distance_to(derived(), rhs) < 0; + return access_t::distance_to(a, b) < 0; } - bool operator>=(const DerivedT& rhs) const + friend bool operator>=(const DerivedT& a, const DerivedT& b) { static_assert(is_random_access, ""); - return access_t::distance_to(derived(), rhs) <= 0; + return access_t::distance_to(a, b) <= 0; } }; diff --git a/immer/detail/rbts/node.hpp b/immer/detail/rbts/node.hpp index 67c9a295..55a512b0 100644 --- a/immer/detail/rbts/node.hpp +++ b/immer/detail/rbts/node.hpp @@ -199,17 +199,23 @@ struct node } static ownee_t& ownee(node_t* x) { return get(x->impl); } - static node_t* make_inner_n(count_t n) + static node_t* make_inner_n_into(void* buffer, std::size_t size, count_t n) { assert(n <= branches); - auto m = heap::allocate(sizeof_inner_n(n)); - auto p = new (m) node_t; + assert(size >= sizeof_inner_n(n)); + auto p = new (buffer) node_t; p->impl.d.data.inner.relaxed = nullptr; #if IMMER_TAGGED_NODE p->impl.d.kind = node_t::kind_t::inner; #endif return p; } + static node_t* make_inner_n(count_t n) + { + assert(n <= branches); + auto m = heap::allocate(sizeof_inner_n(n)); + return make_inner_n_into(m, sizeof_inner_n(n), n); + } static node_t* make_inner_e(edit_t e) { @@ -310,16 +316,24 @@ struct node }); } - static node_t* make_leaf_n(count_t n) + static node_t* make_leaf_n_into(void* buffer, std::size_t size, count_t n) { assert(n <= branches); - auto p = new (heap::allocate(sizeof_leaf_n(n))) node_t; + assert(size >= sizeof_leaf_n(n)); + auto p = new (buffer) node_t; #if IMMER_TAGGED_NODE p->impl.d.kind = node_t::kind_t::leaf; #endif return p; } + static node_t* make_leaf_n(count_t n) + { + assert(n <= branches); + auto m = heap::allocate(sizeof_leaf_n(n)); + return make_leaf_n_into(m, sizeof_leaf_n(n), n); + } + static node_t* make_leaf_e(edit_t e) { auto p = new (heap::allocate(max_sizeof_leaf)) node_t; @@ -511,7 +525,7 @@ struct node IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); auto dst = make_inner_n(n); inc_nodes(src->inner(), n); - std::uninitialized_copy(src->inner(), src->inner() + n, dst->inner()); + std::copy(src->inner(), src->inner() + n, dst->inner()); return dst; } @@ -536,7 +550,20 @@ struct node IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); auto p = src->inner(); inc_nodes(p, n); - std::uninitialized_copy(p, p + n, dst->inner()); + std::copy(p, p + n, dst->inner()); + return dst; + } + + static node_t* do_copy_inner_replace( + node_t* dst, node_t* src, count_t n, count_t offset, node_t* child) + { + IMMER_ASSERT_TAGGED(dst->kind() == kind_t::inner); + IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); + auto p = src->inner(); + inc_nodes(p, offset); + inc_nodes(p + offset + 1, n - offset - 1); + std::copy(p, p + n, dst->inner()); + dst->inner()[offset] = child; return dst; } @@ -582,6 +609,23 @@ struct node return dst; } + static node_t* do_copy_inner_replace_r( + node_t* dst, node_t* src, count_t n, count_t offset, node_t* child) + { + IMMER_ASSERT_TAGGED(dst->kind() == kind_t::inner); + IMMER_ASSERT_TAGGED(src->kind() == kind_t::inner); + auto src_r = src->relaxed(); + auto dst_r = dst->relaxed(); + auto p = src->inner(); + inc_nodes(p, offset); + inc_nodes(p + offset + 1, n - offset - 1); + std::copy(src->inner(), src->inner() + n, dst->inner()); + std::copy(src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); + dst_r->d.count = n; + dst->inner()[offset] = child; + return dst; + } + static node_t* do_copy_inner_sr(node_t* dst, node_t* src, count_t n) { if (embed_relaxed) @@ -593,12 +637,28 @@ struct node } } + static node_t* do_copy_inner_replace_sr( + node_t* dst, node_t* src, count_t n, count_t offset, node_t* child) + { + if (embed_relaxed) + return do_copy_inner_replace_r(dst, src, n, offset, child); + else { + auto p = src->inner(); + inc_nodes(p, offset); + inc_nodes(p + offset + 1, n - offset - 1); + std::copy(p, p + n, dst->inner()); + dst->inner()[offset] = child; + return dst; + } + } + static node_t* copy_leaf(node_t* src, count_t n) { IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); auto dst = make_leaf_n(n); IMMER_TRY { - std::uninitialized_copy(src->leaf(), src->leaf() + n, dst->leaf()); + detail::uninitialized_copy( + src->leaf(), src->leaf() + n, dst->leaf()); } IMMER_CATCH (...) { heap::deallocate(node_t::sizeof_leaf_n(n), dst); @@ -612,7 +672,8 @@ struct node IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); auto dst = make_leaf_e(e); IMMER_TRY { - std::uninitialized_copy(src->leaf(), src->leaf() + n, dst->leaf()); + detail::uninitialized_copy( + src->leaf(), src->leaf() + n, dst->leaf()); } IMMER_CATCH (...) { heap::deallocate(node_t::max_sizeof_leaf, dst); @@ -627,7 +688,8 @@ struct node IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); auto dst = make_leaf_n(allocn); IMMER_TRY { - std::uninitialized_copy(src->leaf(), src->leaf() + n, dst->leaf()); + detail::uninitialized_copy( + src->leaf(), src->leaf() + n, dst->leaf()); } IMMER_CATCH (...) { heap::deallocate(node_t::sizeof_leaf_n(allocn), dst); @@ -642,7 +704,7 @@ struct node IMMER_ASSERT_TAGGED(src2->kind() == kind_t::leaf); auto dst = make_leaf_n(n1 + n2); IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src1->leaf(), src1->leaf() + n1, dst->leaf()); } IMMER_CATCH (...) { @@ -650,11 +712,11 @@ struct node IMMER_RETHROW; } IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src2->leaf(), src2->leaf() + n2, dst->leaf() + n1); } IMMER_CATCH (...) { - destroy_n(dst->leaf(), n1); + detail::destroy_n(dst->leaf(), n1); heap::deallocate(node_t::sizeof_leaf_n(n1 + n2), dst); IMMER_RETHROW; } @@ -668,7 +730,7 @@ struct node IMMER_ASSERT_TAGGED(src2->kind() == kind_t::leaf); auto dst = make_leaf_e(e); IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src1->leaf(), src1->leaf() + n1, dst->leaf()); } IMMER_CATCH (...) { @@ -676,11 +738,11 @@ struct node IMMER_RETHROW; } IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src2->leaf(), src2->leaf() + n2, dst->leaf() + n1); } IMMER_CATCH (...) { - destroy_n(dst->leaf(), n1); + detail::destroy_n(dst->leaf(), n1); heap::deallocate(max_sizeof_leaf, dst); IMMER_RETHROW; } @@ -692,7 +754,7 @@ struct node IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); auto dst = make_leaf_e(e); IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src->leaf() + idx, src->leaf() + last, dst->leaf()); } IMMER_CATCH (...) { @@ -707,7 +769,7 @@ struct node IMMER_ASSERT_TAGGED(src->kind() == kind_t::leaf); auto dst = make_leaf_n(last - idx); IMMER_TRY { - std::uninitialized_copy( + detail::uninitialized_copy( src->leaf() + idx, src->leaf() + last, dst->leaf()); } IMMER_CATCH (...) { @@ -725,7 +787,7 @@ struct node new (dst->leaf() + n) T{std::forward(x)}; } IMMER_CATCH (...) { - destroy_n(dst->leaf(), n); + detail::destroy_n(dst->leaf(), n); heap::deallocate(node_t::sizeof_leaf_n(n + 1), dst); IMMER_RETHROW; } @@ -788,7 +850,7 @@ struct node static void delete_leaf(node_t* p, count_t n) { IMMER_ASSERT_TAGGED(p->kind() == kind_t::leaf); - destroy_n(p->leaf(), n); + detail::destroy_n(p->leaf(), n); heap::deallocate(ownee(p).owned() ? node_t::max_sizeof_leaf : node_t::sizeof_leaf_n(n), p); @@ -814,10 +876,12 @@ struct node auto dst_r = impl.d.data.inner.relaxed = new (heap::allocate(max_sizeof_relaxed)) relaxed_t; if (src_r) { - node_t::refs(src_r).dec_unsafe(); auto n = dst_r->d.count = src_r->d.count; std::copy( src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); + if (node_t::refs(src_r).dec()) + heap::deallocate(node_t::sizeof_inner_r_n(n), + src_r); } node_t::ownee(dst_r) = e; return dst_r; @@ -839,10 +903,12 @@ struct node auto dst_r = impl.d.data.inner.relaxed = new (heap::allocate(max_sizeof_relaxed)) relaxed_t; if (src_r) { - node_t::refs(src_r).dec_unsafe(); auto n = dst_r->d.count = src_r->d.count; std::copy( src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); + if (node_t::refs(src_r).dec()) + heap::deallocate(node_t::sizeof_inner_r_n(n), + src_r); } node_t::ownee(dst_r) = ec; return dst_r; @@ -863,9 +929,11 @@ struct node auto dst_r = new (heap::allocate(max_sizeof_relaxed)) relaxed_t; if (src_r) { - node_t::refs(src_r).dec_unsafe(); std::copy( src_r->d.sizes, src_r->d.sizes + n, dst_r->d.sizes); + if (node_t::refs(src_r).dec()) + heap::deallocate(node_t::sizeof_inner_r_n(n), + src_r); } dst_r->d.count = n; node_t::ownee(dst_r) = e; @@ -887,7 +955,6 @@ struct node } bool dec() const { return refs(this).dec(); } - void dec_unsafe() const { refs(this).dec_unsafe(); } static void inc_nodes(node_t** p, count_t n) { diff --git a/immer/detail/rbts/operations.hpp b/immer/detail/rbts/operations.hpp index 8543915a..d5ff6793 100644 --- a/immer/detail/rbts/operations.hpp +++ b/immer/detail/rbts/operations.hpp @@ -92,7 +92,7 @@ struct for_each_chunk_visitor : visitor_base static void visit_leaf(Pos&& pos, Fn&& fn) { auto data = pos.node()->leaf(); - fn(data, data + pos.count()); + fn(as_const(data), as_const(data) + pos.count()); } }; @@ -109,7 +109,7 @@ struct for_each_chunk_p_visitor : visitor_base template static bool visit_leaf(Pos&& pos, Fn&& fn) { - auto data = pos.node()->leaf(); + auto data = as_const(pos.node()->leaf()); return fn(data, data + pos.count()); } }; @@ -468,9 +468,8 @@ struct update_visitor : visitor_base> auto node = node_t::make_inner_sr_n(count, pos.relaxed()); IMMER_TRY { auto child = pos.towards_oh(this_t{}, idx, offset, fn); - node_t::do_copy_inner_sr(node, pos.node(), count); - node->inner()[offset]->dec_unsafe(); - node->inner()[offset] = child; + node_t::do_copy_inner_replace_sr( + node, pos.node(), count, offset, child); return node; } IMMER_CATCH (...) { @@ -487,9 +486,8 @@ struct update_visitor : visitor_base> auto node = node_t::make_inner_n(count); IMMER_TRY { auto child = pos.towards_oh_ch(this_t{}, idx, offset, count, fn); - node_t::do_copy_inner(node, pos.node(), count); - node->inner()[offset]->dec_unsafe(); - node->inner()[offset] = child; + node_t::do_copy_inner_replace( + node, pos.node(), count, offset, child); return node; } IMMER_CATCH (...) { @@ -1067,8 +1065,8 @@ struct slice_right_mut_visitor node->inc(); return std::make_tuple(0, nullptr, new_tail_size, node); } else if (mutate) { - destroy_n(node->leaf() + new_tail_size, - old_tail_size - new_tail_size); + detail::destroy_n(node->leaf() + new_tail_size, + old_tail_size - new_tail_size); return std::make_tuple(0, nullptr, new_tail_size, node); } else { auto new_tail = node_t::copy_leaf_e(e, node, new_tail_size); @@ -1183,8 +1181,8 @@ struct slice_right_visitor : visitor_base> auto old_tail_size = pos.count(); auto new_tail_size = pos.index(last) + 1; auto new_tail = new_tail_size == old_tail_size - ? pos.node()->inc() - : node_t::copy_leaf(pos.node(), new_tail_size); + ? pos.node()->inc() + : node_t::copy_leaf(pos.node(), new_tail_size); return std::make_tuple(0, nullptr, new_tail_size, new_tail); } }; @@ -1263,10 +1261,10 @@ struct slice_left_mut_visitor return r; } else { using std::get; - auto newn = mutate ? (node->ensure_mutable_relaxed(e), node) - : node_t::make_inner_r_e(e); - auto newr = newn->relaxed(); - auto newcount = count - idx; + auto newn = mutate ? (node->ensure_mutable_relaxed(e), node) + : node_t::make_inner_r_e(e); + auto newr = newn->relaxed(); + auto newcount = count - idx; auto new_child_size = child_size - child_dropped_size; IMMER_TRY { auto subs = @@ -1277,9 +1275,9 @@ struct slice_left_mut_visitor pos.each_left(dec_visitor{}, idx); pos.copy_sizes( idx + 1, newcount - 1, new_child_size, newr->d.sizes + 1); - std::uninitialized_copy(node->inner() + idx + 1, - node->inner() + count, - newn->inner() + 1); + std::copy(node->inner() + idx + 1, + node->inner() + count, + newn->inner() + 1); newn->inner()[0] = get<1>(subs); newr->d.sizes[0] = new_child_size; newr->d.count = newcount; @@ -1348,9 +1346,9 @@ struct slice_left_mut_visitor idx + 1, newcount - 1, newr->d.sizes[0], newr->d.sizes + 1); newr->d.count = newcount; newn->inner()[0] = get<1>(subs); - std::uninitialized_copy(node->inner() + idx + 1, - node->inner() + count, - newn->inner() + 1); + std::copy(node->inner() + idx + 1, + node->inner() + count, + newn->inner() + 1); if (!mutate) { node_t::inc_nodes(newn->inner() + 1, newcount - 1); if (Mutating) @@ -1386,7 +1384,7 @@ struct slice_left_mut_visitor auto data = node->leaf(); auto newcount = count - idx; std::move(data + idx, data + count, data); - destroy_n(data + newcount, idx); + detail::destroy_n(data + newcount, idx); return std::make_tuple(0, node); } else { auto newn = node_t::copy_leaf_e(e, node, idx, count); @@ -1439,9 +1437,9 @@ struct slice_left_visitor : visitor_base> assert(newr->d.sizes[newr->d.count - 1] == pos.size() - dropped_size); newn->inner()[0] = get<1>(subs); - std::uninitialized_copy(n->inner() + idx + 1, - n->inner() + count, - newn->inner() + 1); + std::copy(n->inner() + idx + 1, + n->inner() + count, + newn->inner() + 1); node_t::inc_nodes(newn->inner() + 1, newr->d.count - 1); return std::make_tuple(pos.shift(), newn); } @@ -1627,9 +1625,9 @@ struct concat_merger auto data = to_->leaf(); auto to_copy = std::min(from_count - from_offset, *curr_ - to_offset_); - std::uninitialized_copy(from_data + from_offset, - from_data + from_offset + to_copy, - data + to_offset_); + detail::uninitialized_copy(from_data + from_offset, + from_data + from_offset + to_copy, + data + to_offset_); to_offset_ += to_copy; from_offset += to_copy; if (*curr_ == to_offset_) { @@ -1662,9 +1660,9 @@ struct concat_merger auto data = to_->inner(); auto to_copy = std::min(from_count - from_offset, *curr_ - to_offset_); - std::uninitialized_copy(from_data + from_offset, - from_data + from_offset + to_copy, - data + to_offset_); + std::copy(from_data + from_offset, + from_data + from_offset + to_copy, + data + to_offset_); node_t::inc_nodes(from_data + from_offset, to_copy); auto sizes = to_->relaxed()->d.sizes; p.copy_sizes( @@ -2124,10 +2122,10 @@ struct concat_merger_mut data + to_offset_); } else { if (!from_mutate) - std::uninitialized_copy(from_data + from_offset, - from_data + from_offset + - to_copy, - data + to_offset_); + detail::uninitialized_copy(from_data + from_offset, + from_data + from_offset + + to_copy, + data + to_offset_); else detail::uninitialized_move(from_data + from_offset, from_data + from_offset + diff --git a/immer/detail/rbts/rbtree.hpp b/immer/detail/rbts/rbtree.hpp index 0b016a0e..c8fa4251 100644 --- a/immer/detail/rbts/rbtree.hpp +++ b/immer/detail/rbts/rbtree.hpp @@ -15,9 +15,9 @@ #include #include -#include #include #include +#include namespace immer { namespace detail { @@ -465,7 +465,7 @@ struct rbtree auto ts = size - tail_off; auto newts = new_size - tail_off; if (tail->can_mutate(e)) { - destroy_n(tail->leaf() + newts, ts - newts); + detail::destroy_n(tail->leaf() + newts, ts - newts); } else { auto new_tail = node_t::copy_leaf_e(e, tail, newts); dec_leaf(tail, ts); diff --git a/immer/detail/rbts/rrbtree.hpp b/immer/detail/rbts/rrbtree.hpp index 4075e0c9..25235e44 100644 --- a/immer/detail/rbts/rrbtree.hpp +++ b/immer/detail/rbts/rrbtree.hpp @@ -16,10 +16,10 @@ #include #include -#include +#include #include #include -#include +#include namespace immer { namespace detail { @@ -92,7 +92,7 @@ struct rrbtree return result; } - rrbtree() + rrbtree() noexcept : size{0} , shift{BL} , root{empty_root()} @@ -101,7 +101,7 @@ struct rrbtree assert(check_tree()); } - rrbtree(size_t sz, shift_t sh, node_t* r, node_t* t) + rrbtree(size_t sz, shift_t sh, node_t* r, node_t* t) noexcept : size{sz} , shift{sh} , root{r} @@ -110,13 +110,13 @@ struct rrbtree assert(check_tree()); } - rrbtree(const rrbtree& other) + rrbtree(const rrbtree& other) noexcept : rrbtree{other.size, other.shift, other.root, other.tail} { inc(); } - rrbtree(rrbtree&& other) + rrbtree(rrbtree&& other) noexcept : rrbtree{} { swap(*this, other); @@ -129,13 +129,13 @@ struct rrbtree return *this; } - rrbtree& operator=(rrbtree&& other) + rrbtree& operator=(rrbtree&& other) noexcept { swap(*this, other); return *this; } - friend void swap(rrbtree& x, rrbtree& y) + friend void swap(rrbtree& x, rrbtree& y) noexcept { using std::swap; swap(x.size, y.size); @@ -160,9 +160,10 @@ struct rrbtree { auto r = root->relaxed(); assert(r == nullptr || r->d.count); - return r ? r->d.sizes[r->d.count - 1] - : size ? (size - 1) & ~mask - /* otherwise */ : 0; + return r ? r->d.sizes[r->d.count - 1] + : size ? (size - 1) & ~mask + /* otherwise */ + : 0; } template @@ -312,15 +313,15 @@ struct rrbtree return tail_off == tail_off_other ? make_leaf_sub_pos(tail, tail_size()) .visit(equals_visitor{}, other.tail) - : tail_off > tail_off_other - ? std::equal(tail->leaf(), - tail->leaf() + (size - tail_off), - other.tail->leaf() + - (tail_off - tail_off_other)) - /* otherwise */ - : std::equal(tail->leaf(), - tail->leaf() + (size - tail_off), - iter_t{other} + tail_off); + : tail_off > tail_off_other + ? std::equal(tail->leaf(), + tail->leaf() + (size - tail_off), + other.tail->leaf() + + (tail_off - tail_off_other)) + /* otherwise */ + : std::equal(tail->leaf(), + tail->leaf() + (size - tail_off), + iter_t{other} + tail_off); } std::tuple push_tail(node_t* root, @@ -575,7 +576,7 @@ struct rrbtree auto ts = size - tail_off; auto newts = new_size - tail_off; if (tail->can_mutate(e)) { - destroy_n(tail->leaf() + newts, ts - newts); + detail::destroy_n(tail->leaf() + newts, ts - newts); } else { auto new_tail = node_t::copy_leaf_e(e, tail, newts); dec_leaf(tail, ts); @@ -794,17 +795,17 @@ struct rrbtree return; } else if (tail_size + r.size <= branches) { l.ensure_mutable_tail(el, tail_size); - std::uninitialized_copy(r.tail->leaf(), - r.tail->leaf() + r.size, - l.tail->leaf() + tail_size); + detail::uninitialized_copy(r.tail->leaf(), + r.tail->leaf() + r.size, + l.tail->leaf() + tail_size); l.size += r.size; return; } else { auto remaining = branches - tail_size; l.ensure_mutable_tail(el, tail_size); - std::uninitialized_copy(r.tail->leaf(), - r.tail->leaf() + remaining, - l.tail->leaf() + tail_size); + detail::uninitialized_copy(r.tail->leaf(), + r.tail->leaf() + remaining, + l.tail->leaf() + tail_size); IMMER_TRY { auto new_tail = node_t::copy_leaf_e(el, r.tail, remaining, r.size); @@ -820,7 +821,7 @@ struct rrbtree } } IMMER_CATCH (...) { - destroy_n(r.tail->leaf() + tail_size, remaining); + detail::destroy_n(r.tail->leaf() + tail_size, remaining); IMMER_RETHROW; } } @@ -893,9 +894,9 @@ struct rrbtree r.shift, r.tail_offset()); l = {l.size + r.size, - concated.shift(), - concated.node(), - r.tail->inc()}; + concated.shift(), + concated.node(), + r.tail->inc()}; } } } @@ -954,9 +955,9 @@ struct rrbtree add_tail, branches); r = {l.size + r.size, - get<0>(new_root), - get<1>(new_root), - new_tail}; + get<0>(new_root), + get<1>(new_root), + new_tail}; return; } IMMER_CATCH (...) { @@ -1034,9 +1035,9 @@ struct rrbtree r.shift, r.tail_offset()); r = {l.size + r.size, - concated.shift(), - concated.node(), - r.tail->inc()}; + concated.shift(), + concated.node(), + r.tail->inc()}; return; } } @@ -1067,9 +1068,9 @@ struct rrbtree r.tail->leaf() + r.size, l.tail->leaf() + tail_size); else - std::uninitialized_copy(r.tail->leaf(), - r.tail->leaf() + r.size, - l.tail->leaf() + tail_size); + detail::uninitialized_copy(r.tail->leaf(), + r.tail->leaf() + r.size, + l.tail->leaf() + tail_size); l.size += r.size; return; } else { @@ -1080,9 +1081,9 @@ struct rrbtree r.tail->leaf() + remaining, l.tail->leaf() + tail_size); else - std::uninitialized_copy(r.tail->leaf(), - r.tail->leaf() + remaining, - l.tail->leaf() + tail_size); + detail::uninitialized_copy(r.tail->leaf(), + r.tail->leaf() + remaining, + l.tail->leaf() + tail_size); IMMER_TRY { auto new_tail = node_t::copy_leaf_e(el, r.tail, remaining, r.size); @@ -1098,7 +1099,7 @@ struct rrbtree } } IMMER_CATCH (...) { - destroy_n(r.tail->leaf() + tail_size, remaining); + detail::destroy_n(r.tail->leaf() + tail_size, remaining); IMMER_RETHROW; } } @@ -1170,9 +1171,9 @@ struct rrbtree r.shift, r.tail_offset()); l = {l.size + r.size, - concated.shift(), - concated.node(), - r.tail->inc()}; + concated.shift(), + concated.node(), + r.tail->inc()}; return; } } @@ -1231,9 +1232,9 @@ struct rrbtree add_tail, branches); r = {l.size + r.size, - get<0>(new_root), - get<1>(new_root), - new_tail}; + get<0>(new_root), + get<1>(new_root), + new_tail}; return; } IMMER_CATCH (...) { @@ -1314,9 +1315,9 @@ struct rrbtree r.shift, r.tail_offset()); r = {l.size + r.size, - concated.shift(), - concated.node(), - r.tail->inc()}; + concated.shift(), + concated.node(), + r.tail->inc()}; } } } diff --git a/immer/detail/type_traits.hpp b/immer/detail/type_traits.hpp index afb2652c..091fe04d 100644 --- a/immer/detail/type_traits.hpp +++ b/immer/detail/type_traits.hpp @@ -201,23 +201,5 @@ struct std_distance_supports< template constexpr bool std_distance_supports_v = std_distance_supports::value; -template -struct std_uninitialized_copy_supports : std::false_type -{}; - -template -struct std_uninitialized_copy_supports< - T, - U, - V, - void_t(), std::declval(), std::declval()))>> - : std::true_type -{}; - -template -constexpr bool std_uninitialized_copy_supports_v = - std_uninitialized_copy_supports::value; - } // namespace detail } // namespace immer diff --git a/immer/detail/util.hpp b/immer/detail/util.hpp index b9e50414..d6ae246b 100644 --- a/immer/detail/util.hpp +++ b/immer/detail/util.hpp @@ -24,6 +24,18 @@ namespace immer { namespace detail { +template +const T* as_const(T* x) +{ + return x; +} + +template +const T& as_const(T& x) +{ + return x; +} + template using aligned_storage_for = typename std::aligned_storage::type; @@ -39,26 +51,110 @@ T&& auto_const_cast(const T&& x) return const_cast(std::move(x)); } -template -auto uninitialized_move(Iter1 in1, Iter1 in2, Iter2 out) +template +inline auto destroy_at(T* p) noexcept + -> std::enable_if_t::value> { - return std::uninitialized_copy( - std::make_move_iterator(in1), std::make_move_iterator(in2), out); + p->~T(); } template -void destroy(T* first, T* last) +inline auto destroy_at(T* p) noexcept + -> std::enable_if_t::value> +{ + p->~T(); +} + +template +constexpr bool can_trivially_detroy = std::is_trivially_destructible< + typename std::iterator_traits::value_type>::value; + +template +auto destroy(Iter, Iter last) noexcept + -> std::enable_if_t, Iter> +{ + return last; +} +template +auto destroy(Iter first, Iter last) noexcept + -> std::enable_if_t, Iter> { for (; first != last; ++first) - first->~T(); + detail::destroy_at(std::addressof(*first)); + return first; +} + +template +auto destroy_n(Iter first, Size n) noexcept + -> std::enable_if_t, Iter> +{ + return first + n; +} +template +auto destroy_n(Iter first, Size n) noexcept + -> std::enable_if_t, Iter> +{ + for (; n > 0; (void) ++first, --n) + detail::destroy_at(std::addressof(*first)); + return first; +} + +template +constexpr bool can_trivially_copy = + std::is_same::value_type, + typename std::iterator_traits::value_type>::value&& + std::is_trivially_copyable< + typename std::iterator_traits::value_type>::value; + +template +auto uninitialized_move(Iter1 first, Iter1 last, Iter2 out) noexcept + -> std::enable_if_t, Iter2> +{ + return std::copy(first, last, out); +} +template +auto uninitialized_move(Iter1 first, Iter1 last, Iter2 out) + -> std::enable_if_t, Iter2> + +{ + using value_t = typename std::iterator_traits::value_type; + auto current = out; + IMMER_TRY { + for (; first != last; ++first, (void) ++current) { + ::new (const_cast(static_cast( + std::addressof(*current)))) value_t(std::move(*first)); + } + return current; + } + IMMER_CATCH (...) { + detail::destroy(out, current); + IMMER_RETHROW; + } } -template -void destroy_n(T* p, Size n) +template +auto uninitialized_copy(SourceIter first, Sent last, SinkIter out) noexcept + -> std::enable_if_t, SinkIter> +{ + return std::copy(first, last, out); +} +template +auto uninitialized_copy(SourceIter first, Sent last, SinkIter out) + -> std::enable_if_t, SinkIter> { - auto e = p + n; - for (; p != e; ++p) - p->~T(); + using value_t = typename std::iterator_traits::value_type; + auto current = out; + IMMER_TRY { + for (; first != last; ++first, (void) ++current) { + ::new (const_cast(static_cast( + std::addressof(*current)))) value_t(*first); + } + return current; + } + IMMER_CATCH (...) { + detail::destroy(out, current); + IMMER_RETHROW; + } } template @@ -214,53 +310,5 @@ distance(Iterator first, Sentinel last) return last - first; } -/*! - * An alias to `std::uninitialized_copy` - */ -template < - typename Iterator, - typename Sentinel, - typename SinkIter, - std::enable_if_t< - detail::std_uninitialized_copy_supports_v, - bool> = true> -SinkIter uninitialized_copy(Iterator first, Sentinel last, SinkIter d_first) -{ - return std::uninitialized_copy(first, last, d_first); -} - -/*! - * Equivalent of the `std::uninitialized_copy` applied to the - * sentinel-delimited forward range @f$ [first, last) @f$ - */ -template ) &&detail:: - compatible_sentinel_v && - detail::is_forward_iterator_v, - bool> = true> -SinkIter uninitialized_copy(SourceIter first, Sent last, SinkIter d_first) -{ - auto current = d_first; - IMMER_TRY { - while (first != last) { - *current++ = *first; - ++first; - } - } - IMMER_CATCH (...) { - using Value = typename std::iterator_traits::value_type; - for (; d_first != current; ++d_first) { - d_first->~Value(); - } - IMMER_RETHROW; - } - return current; -} - } // namespace detail } // namespace immer diff --git a/immer/flex_vector.hpp b/immer/flex_vector.hpp index 47a82abe..f970db91 100644 --- a/immer/flex_vector.hpp +++ b/immer/flex_vector.hpp @@ -249,7 +249,7 @@ class flex_vector } /*! - * Returns a flex_vector with `value` inserted at the frony. It may + * Returns a flex_vector with `value` inserted at the front. It may * allocate memory and its complexity is @f$ O(log(size)) @f$. * * @rst @@ -503,6 +503,17 @@ class flex_vector IMMER_NODISCARD transient_type transient() const& { return impl_; } IMMER_NODISCARD transient_type transient() && { return std::move(impl_); } + /*! + * Returns a value that can be used as identity for the container. If two + * values have the same identity, they are guaranteed to be equal and to + * contain the same objects. However, two equal containers are not + * guaranteed to have the same identity. + */ + std::pair identity() const + { + return {impl_.root, impl_.tail}; + } + // Semi-private const impl_t& impl() const { return impl_; } @@ -605,4 +616,9 @@ class flex_vector impl_t impl_ = {}; }; +static_assert(std::is_nothrow_move_constructible>::value, + "flex_vector is not nothrow move constructible"); +static_assert(std::is_nothrow_move_assignable>::value, + "flex_vector is not nothrow move assignable"); + } // namespace immer diff --git a/immer/heap/cpp_heap.hpp b/immer/heap/cpp_heap.hpp index 119fceec..37897548 100644 --- a/immer/heap/cpp_heap.hpp +++ b/immer/heap/cpp_heap.hpp @@ -33,7 +33,7 @@ struct cpp_heap * `allocate`. One must not use nor deallocate again a memory * region that once it has been deallocated. */ - static void deallocate(std::size_t size, void* data) + static void deallocate(std::size_t, void* data) { ::operator delete(data); } diff --git a/immer/heap/heap_policy.hpp b/immer/heap/heap_policy.hpp index 582c113f..1a858c5e 100644 --- a/immer/heap/heap_policy.hpp +++ b/immer/heap/heap_policy.hpp @@ -85,8 +85,7 @@ struct enable_optimized_heap_policy * @rst * * .. tip:: For many applications that use immutable data structures - * significantly, this is actually the best heap policy, and it - * might become the default in the future. + * significantly, this is actually the best heap policy. * * Note that most our data structures internally use trees with the * same big branching factors. This means that all *vectors*, diff --git a/immer/map.hpp b/immer/map.hpp index e12d7ee0..cab8e5d5 100644 --- a/immer/map.hpp +++ b/immer/map.hpp @@ -14,8 +14,8 @@ #include #include -#include #include +#include namespace immer { @@ -41,7 +41,7 @@ class map_transient; * * @rst * - * This cotainer provides a good trade-off between cache locality, + * This container provides a good trade-off between cache locality, * search, update performance and structural sharing. It does so by * storing the data in contiguous chunks of :math:`2^{B}` elements. * When storing big objects, the size of these contiguous chunks can @@ -68,12 +68,19 @@ class map { using value_t = std::pair; + using move_t = + std::integral_constant; + struct project_value { const T& operator()(const value_t& v) const noexcept { return v.second; } + T&& operator()(value_t&& v) const noexcept + { + return std::move(v.second); + } }; struct project_value_ptr @@ -114,8 +121,11 @@ class map { auto operator()(const value_t& v) { return Hash{}(v.first); } - template - auto operator()(const Key& v) { return Hash{}(v); } + template + auto operator()(const Key& v) + { + return Hash{}(v); + } }; struct equal_key @@ -125,7 +135,7 @@ class map return Equal{}(a.first, b.first); } - template + template auto operator()(const value_t& a, const Key& b) { return Equal{}(a.first, b); @@ -160,8 +170,29 @@ class map using transient_type = map_transient; + using memory_policy_type = MemoryPolicy; + + /*! + * Constructs a map containing the elements in `values`. + */ + map(std::initializer_list values) + : impl_{impl_t::from_initializer_list(values)} + {} + /*! - * Default constructor. It creates a set of `size() == 0`. It + * Constructs a map containing the elements in the range + * defined by the input iterator `first` and range sentinel `last`. + */ + template , + bool> = true> + map(Iter first, Sent last) + : impl_{impl_t::from_range(first, last)} + {} + + /*! + * Default constructor. It creates a map of `size() == 0`. It * does not allocate memory and its complexity is @f$ O(1) @f$. */ map() = default; @@ -202,7 +233,9 @@ class map * This overload participates in overload resolution only if * `Hash::is_transparent` is valid and denotes a type. */ - template + template IMMER_NODISCARD size_type count(const Key& k) const { return impl_.template get, @@ -229,7 +262,9 @@ class map * This overload participates in overload resolution only if * `Hash::is_transparent` is valid and denotes a type. */ - template + template IMMER_NODISCARD const T& operator[](const Key& k) const { return impl_.template get(k); @@ -252,7 +287,9 @@ class map * `std::out_of_range` error. It does not allocate memory and its * complexity is *effectively* @f$ O(1) @f$. */ - template + template const T& at(const Key& k) const { return impl_.template get(k); @@ -297,7 +334,7 @@ class map * ``std::optional`` but this construction is not valid * in any current standard. As a compromise we return a * pointer, which has similar syntactic properties yet it is - * unfortunatelly unnecessarily unrestricted. + * unfortunately unnecessarily unrestricted. * * @endrst */ @@ -307,7 +344,6 @@ class map detail::constantly>(k); } - /*! * Returns a pointer to the value associated with the key `k`. If * the key is not contained in the map, a `nullptr` is returned. @@ -317,7 +353,9 @@ class map * This overload participates in overload resolution only if * `Hash::is_transparent` is valid and denotes a type. */ - template + template IMMER_NODISCARD const T* find(const Key& k) const { return impl_.template get - IMMER_NODISCARD map update(key_type k, Fn&& fn) const + IMMER_NODISCARD map update(key_type k, Fn&& fn) const& { return impl_ .template update( std::move(k), std::forward(fn)); } + template + IMMER_NODISCARD decltype(auto) update(key_type k, Fn&& fn) && + { + return update_move(move_t{}, std::move(k), std::forward(fn)); + } + + /*! + * Returns a map replacing the association `(k, v)` by the association new + * association `(k, fn(v))`, where `v` is the currently associated value for + * `k` in the map. It does nothing if `k` is not present in the map. It + * may allocate memory and its complexity is *effectively* @f$ O(1) @f$. + */ + template + IMMER_NODISCARD map update_if_exists(key_type k, Fn&& fn) const& + { + return impl_.template update_if_exists( + std::move(k), std::forward(fn)); + } + template + IMMER_NODISCARD decltype(auto) update_if_exists(key_type k, Fn&& fn) && + { + return update_if_exists_move( + move_t{}, std::move(k), std::forward(fn)); + } /*! * Returns a map without the key `k`. If the key is not * associated in the map it returns the same map. It may allocate * memory and its complexity is *effectively* @f$ O(1) @f$. */ - IMMER_NODISCARD map erase(const K& k) const { return impl_.sub(k); } + IMMER_NODISCARD map erase(const K& k) const& { return impl_.sub(k); } + IMMER_NODISCARD decltype(auto) erase(const K& k) && + { + return erase_move(move_t{}, k); + } /*! - * Returns an @a transient form of this container, a + * Returns a @a transient form of this container, an * `immer::map_transient`. */ IMMER_NODISCARD transient_type transient() const& @@ -393,12 +467,79 @@ class map return transient_type{std::move(impl_)}; } + /*! + * Returns a value that can be used as identity for the container. If two + * values have the same identity, they are guaranteed to be equal and to + * contain the same objects. However, two equal containers are not + * guaranteed to have the same identity. + */ + void* identity() const { return impl_.root; } + // Semi-private const impl_t& impl() const { return impl_; } private: friend transient_type; + map&& insert_move(std::true_type, value_type value) + { + impl_.add_mut({}, std::move(value)); + return std::move(*this); + } + map insert_move(std::false_type, value_type value) + { + return impl_.add(std::move(value)); + } + + map&& set_move(std::true_type, key_type k, mapped_type m) + { + impl_.add_mut({}, {std::move(k), std::move(m)}); + return std::move(*this); + } + map set_move(std::false_type, key_type k, mapped_type m) + { + return impl_.add({std::move(k), std::move(m)}); + } + + template + map&& update_move(std::true_type, key_type k, Fn&& fn) + { + impl_.template update_mut( + {}, std::move(k), std::forward(fn)); + return std::move(*this); + } + template + map update_move(std::false_type, key_type k, Fn&& fn) + { + return impl_ + .template update( + std::move(k), std::forward(fn)); + } + + template + map&& update_if_exists_move(std::true_type, key_type k, Fn&& fn) + { + impl_.template update_if_exists_mut( + {}, std::move(k), std::forward(fn)); + return std::move(*this); + } + template + map update_if_exists_move(std::false_type, key_type k, Fn&& fn) + { + return impl_.template update_if_exists( + std::move(k), std::forward(fn)); + } + + map&& erase_move(std::true_type, const key_type& value) + { + impl_.sub_mut({}, value); + return std::move(*this); + } + map erase_move(std::false_type, const key_type& value) + { + return impl_.sub(value); + } + map(impl_t impl) : impl_(std::move(impl)) {} diff --git a/immer/map_transient.hpp b/immer/map_transient.hpp index 8821c5d1..935f48e2 100644 --- a/immer/map_transient.hpp +++ b/immer/map_transient.hpp @@ -15,18 +15,21 @@ namespace immer { +template +class map; + /*! - * @rst + * Mutable version of `immer::map`. * - * .. admonition:: Become a sponsor! - * :class: danger - * - * This component is planned but it has **not been implemented yet**. + * @rst * - * Transiens can critically improve the performance of applications - * intensively using ``set`` and ``map``. If you are working for an - * organization using the library in a commercial project, please consider - * **sponsoring this work**: juanpe@sinusoid.al + * Refer to :doc:`transients` to learn more about when and how to use + * the mutable versions of immutable containers. * * @endrst */ @@ -36,6 +39,280 @@ template , typename MemoryPolicy = default_memory_policy, detail::hamts::bits_t B = default_bits> -class map_transient; +class map_transient : MemoryPolicy::transience_t::owner +{ + using base_t = typename MemoryPolicy::transience_t::owner; + using owner_t = base_t; + +public: + using persistent_type = map; + + using key_type = K; + using mapped_type = T; + using value_type = std::pair; + using size_type = detail::hamts::size_t; + using diference_type = std::ptrdiff_t; + using hasher = Hash; + using key_equal = Equal; + using reference = const value_type&; + using const_reference = const value_type&; + + using iterator = typename persistent_type::iterator; + using const_iterator = iterator; + + /*! + * Default constructor. It creates a map of `size() == 0`. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + map_transient() = default; + + /*! + * Returns an iterator pointing at the first element of the + * collection. It does not allocate memory and its complexity is + * @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator begin() const { return {impl_}; } + + /*! + * Returns an iterator pointing just after the last element of the + * collection. It does not allocate and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator end() const + { + return {impl_, typename iterator::end_t{}}; + } + + /*! + * Returns the number of elements in the container. It does + * not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type size() const { return impl_.size; } + + /*! + * Returns `true` if there are no elements in the container. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD bool empty() const { return impl_.size == 0; } + + /*! + * Returns `1` when the key `k` is contained in the map or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD size_type count(const Key& k) const + { + return impl_.template get, + detail::constantly>(k); + } + + /*! + * Returns `1` when the key `k` is contained in the map or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type count(const K& k) const + { + return impl_.template get, + detail::constantly>(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If the key is not contained in the map, it returns a + * default constructed value. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T& operator[](const Key& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If the key is not contained in the map, it returns a + * default constructed value. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD const T& operator[](const K& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If the key is not contained in the map, throws an + * `std::out_of_range` error. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + template + const T& at(const Key& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If the key is not contained in the map, throws an + * `std::out_of_range` error. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + const T& at(const K& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a pointer to the value associated with the key `k`. If + * the key is not contained in the map, a `nullptr` is returned. + * It does not allocate memory and its complexity is *effectively* + * @f$ O(1) @f$. + * + * @rst + * + * .. admonition:: Why doesn't this function return an iterator? + * + * Associative containers from the C++ standard library provide a + * ``find`` method that returns an iterator pointing to the + * element in the container or ``end()`` when the key is missing. + * In the case of an unordered container, the only meaningful + * thing one may do with it is to compare it with the end, to + * test if the find was succesfull, and dereference it. This + * comparison is cumbersome compared to testing for a non-empty + * optional value. Furthermore, for an immutable container, + * returning an iterator would have some additional performance + * cost, with no benefits otherwise. + * + * In our opinion, this function should return a + * ``std::optional`` but this construction is not valid + * in any current standard. As a compromise we return a + * pointer, which has similar syntactic properties yet it is + * unfortunately unnecessarily unrestricted. + * + * @endrst + */ + IMMER_NODISCARD const T* find(const K& k) const + { + return impl_.template get>(k); + } + + /*! + * Returns a pointer to the value associated with the key `k`. If + * the key is not contained in the map, a `nullptr` is returned. + * It does not allocate memory and its complexity is *effectively* + * @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T* find(const Key& k) const + { + return impl_.template get>(k); + } + + /*! + * Inserts the association `value`. If the key is already in the map, it + * replaces its association in the map. It may allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + void insert(value_type value) { impl_.add_mut(*this, std::move(value)); } + + /*! + * Inserts the association `(k, v)`. If the key is already in the map, it + * replaces its association in the map. It may allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + void set(key_type k, mapped_type v) + { + impl_.add_mut(*this, {std::move(k), std::move(v)}); + } + + /*! + * Replaces the association `(k, v)` by the association new association `(k, + * fn(v))`, where `v` is the currently associated value for `k` in the map + * or a default constructed value otherwise. It may allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + template + void update(key_type k, Fn&& fn) + { + impl_.template update_mut( + *this, std::move(k), std::forward(fn)); + } + + /*! + * Replaces the association `(k, v)` by the association new association `(k, + * fn(v))`, where `v` is the currently associated value for `k` in the map + * or does nothing if `k` is not present in the map. It may allocate memory + * and its complexity is *effectively* @f$ O(1) @f$. + */ + template + void update_if_exists(key_type k, Fn&& fn) + { + impl_.template update_if_exists_mut< + typename persistent_type::project_value, + typename persistent_type::combine_value>( + *this, std::move(k), std::forward(fn)); + } + + /*! + * Removes the key `k` from the k. Does nothing if the key is not + * associated in the map. It may allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + void erase(const K& k) { impl_.sub_mut(*this, k); } + + /*! + * Returns an @a immutable form of this container, an + * `immer::map`. + */ + IMMER_NODISCARD persistent_type persistent() & + { + this->owner_t::operator=(owner_t{}); + return impl_; + } + IMMER_NODISCARD persistent_type persistent() && { return std::move(impl_); } + +private: + friend persistent_type; + using impl_t = typename persistent_type::impl_t; + + map_transient(impl_t impl) + : impl_(std::move(impl)) + {} + + impl_t impl_ = impl_t::empty(); + +public: + // Semi-private + const impl_t& impl() const { return impl_; } +}; } // namespace immer diff --git a/immer/memory_policy.hpp b/immer/memory_policy.hpp index 2a26f089..82020f27 100644 --- a/immer/memory_policy.hpp +++ b/immer/memory_policy.hpp @@ -30,7 +30,8 @@ struct get_transience_policy : std::conditional::value, gc_transience_policy, no_transience_policy> -{}; +{ +}; template using get_transience_policy_t = typename get_transience_policy::type; @@ -44,7 +45,8 @@ struct get_prefer_fewer_bigger_objects : std::integral_constant< bool, std::is_same>::value> -{}; +{ +}; template constexpr auto get_prefer_fewer_bigger_objects_v = @@ -59,7 +61,8 @@ struct get_use_transient_rvalues : std::integral_constant< bool, !std::is_same::value> -{}; +{ +}; template constexpr auto get_use_transient_rvalues_v = diff --git a/immer/refcount/no_refcount_policy.hpp b/immer/refcount/no_refcount_policy.hpp index d726d2c3..5706858b 100644 --- a/immer/refcount/no_refcount_policy.hpp +++ b/immer/refcount/no_refcount_policy.hpp @@ -24,7 +24,6 @@ struct no_refcount_policy void inc() {} bool dec() { return false; } - void dec_unsafe() {} bool unique() { return false; } }; diff --git a/immer/refcount/refcount_policy.hpp b/immer/refcount/refcount_policy.hpp index 7a8e15a8..52b516e8 100644 --- a/immer/refcount/refcount_policy.hpp +++ b/immer/refcount/refcount_policy.hpp @@ -34,12 +34,6 @@ struct refcount_policy bool dec() { return 1 == refcount.fetch_sub(1, std::memory_order_acq_rel); } - void dec_unsafe() - { - assert(refcount.load() > 1); - refcount.fetch_sub(1, std::memory_order_relaxed); - } - bool unique() { return refcount == 1; } }; diff --git a/immer/refcount/unsafe_refcount_policy.hpp b/immer/refcount/unsafe_refcount_policy.hpp index 0d1417d1..df65019b 100644 --- a/immer/refcount/unsafe_refcount_policy.hpp +++ b/immer/refcount/unsafe_refcount_policy.hpp @@ -31,7 +31,6 @@ struct unsafe_refcount_policy void inc() { ++refcount; } bool dec() { return --refcount == 0; } - void dec_unsafe() { --refcount; } bool unique() { return refcount == 1; } }; diff --git a/immer/set.hpp b/immer/set.hpp index 922b14f5..df4192f5 100644 --- a/immer/set.hpp +++ b/immer/set.hpp @@ -62,13 +62,15 @@ class set { using impl_t = detail::hamts::champ; + using move_t = + std::integral_constant; + struct project_value_ptr { const T* operator()(const T& v) const noexcept { return &v; } }; public: - using key_type = T; using value_type = T; using size_type = detail::hamts::size_t; using diference_type = std::ptrdiff_t; @@ -83,12 +85,33 @@ class set using transient_type = set_transient; + using memory_policy_type = MemoryPolicy; + /*! * Default constructor. It creates a set of `size() == 0`. It * does not allocate memory and its complexity is @f$ O(1) @f$. */ set() = default; + /*! + * Constructs a set containing the elements in `values`. + */ + set(std::initializer_list values) + : impl_{impl_t::from_initializer_list(values)} + {} + + /*! + * Constructs a set containing the elements in the range + * defined by the input iterator `first` and range sentinel `last`. + */ + template , + bool> = true> + set(Iter first, Sent last) + : impl_{impl_t::from_range(first, last)} + {} + /*! * Returns an iterator pointing at the first element of the * collection. It does not allocate memory and its complexity is @@ -125,7 +148,9 @@ class set * This overload participates in overload resolution only if * `Hash::is_transparent` is valid and denotes a type. */ - template + template IMMER_NODISCARD size_type count(const K& value) const { return impl_.template get, @@ -164,7 +189,9 @@ class set * This overload participates in overload resolution only if * `Hash::is_transparent` is valid and denotes a type. */ - template + template IMMER_NODISCARD const T* find(const K& value) const { return impl_.template get, typename MemoryPolicy = default_memory_policy, detail::hamts::bits_t B = default_bits> -class set_transient; +class set_transient : MemoryPolicy::transience_t::owner +{ + using base_t = typename MemoryPolicy::transience_t::owner; + using owner_t = base_t; + +public: + using persistent_type = set; + + using value_type = T; + using size_type = detail::hamts::size_t; + using diference_type = std::ptrdiff_t; + using hasher = Hash; + using key_equal = Equal; + using reference = const T&; + using const_reference = const T&; + + using iterator = typename persistent_type::iterator; + using const_iterator = iterator; + + /*! + * Default constructor. It creates a set of `size() == 0`. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + set_transient() = default; + + /*! + * Returns an iterator pointing at the first element of the + * collection. It does not allocate memory and its complexity is + * @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator begin() const { return {impl_}; } + + /*! + * Returns an iterator pointing just after the last element of the + * collection. It does not allocate and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator end() const + { + return {impl_, typename iterator::end_t{}}; + } + + /*! + * Returns the number of elements in the container. It does + * not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type size() const { return impl_.size; } + + /*! + * Returns `true` if there are no elements in the container. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD bool empty() const { return impl_.size == 0; } + + /*! + * Returns `1` when `value` is contained in the set or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD size_type count(const K& value) const + { + return impl_.template get, + detail::constantly>(value); + } + + /*! + * Returns `1` when `value` is contained in the set or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type count(const T& value) const + { + return impl_.template get, + detail::constantly>(value); + } + + /*! + * Returns a pointer to the value if `value` is contained in the + * set, or nullptr otherwise. + * It does not allocate memory and its complexity is *effectively* + * @f$ O(1) @f$. + */ + IMMER_NODISCARD const T* find(const T& value) const + { + return impl_.template get>(value); + } + + /*! + * Returns a pointer to the value if `value` is contained in the + * set, or nullptr otherwise. + * It does not allocate memory and its complexity is *effectively* + * @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T* find(const K& value) const + { + return impl_.template get>(value); + } + + /*! + * Inserts `value` into the set, and does nothing if the value is already + * there It may allocate memory and its complexity is *effectively* @f$ + * O(1) @f$. + */ + void insert(T value) { impl_.add_mut(*this, std::move(value)); } + + /*! + * Removes the `value` from the set, doing nothing if the value is not in + * the set. It may allocate memory and its complexity is *effectively* @f$ + * O(1) @f$. + */ + void erase(const T& value) { impl_.sub_mut(*this, value); } + + /*! + * Returns an @a immutable form of this container, an + * `immer::set`. + */ + IMMER_NODISCARD persistent_type persistent() & + { + this->owner_t::operator=(owner_t{}); + return impl_; + } + IMMER_NODISCARD persistent_type persistent() && { return std::move(impl_); } + +private: + friend persistent_type; + using impl_t = typename persistent_type::impl_t; + + set_transient(impl_t impl) + : impl_(std::move(impl)) + {} + + impl_t impl_ = impl_t::empty(); + +public: + // Semi-private + const impl_t& impl() const { return impl_; } +}; } // namespace immer diff --git a/immer/table.hpp b/immer/table.hpp new file mode 100644 index 00000000..0e977c6a --- /dev/null +++ b/immer/table.hpp @@ -0,0 +1,547 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace immer { + +template +class table_transient; + +/*! + * Function template to get the key in `immer::table_key_fn`. + * It assumes the key is `id` class member. + */ +template +auto get_table_key(T const& x) -> decltype(x.id) +{ + return x.id; +} + +/*! + * Function template to set the key in `immer::table_key_fn`. + * It assumes the key is `id` class member. + */ +template +auto set_table_key(T x, K&& k) -> T +{ + x.id = std::forward(k); + return x; +} + +/*! + * Default value for `KeyFn` in `immer::table`. + * It assumes the key is `id` class member. + */ +struct table_key_fn +{ + template + decltype(auto) operator()(T&& x) const + { + return get_table_key(std::forward(x)); + } + + template + auto operator()(T&& x, K&& k) const + { + return set_table_key(std::forward(x), std::forward(k)); + } +}; + +template +using table_key_t = std::decay_t()))>; + +/*! + * Immutable unordered set of values of type `T`. Values are indexed via + * `operator()(const T&)` from `KeyFn` template parameter. + * By default, key is `&T::id`. + * + * @tparam T The type of the values to be stored in the container. + * @tparam KeyFn Type which implements `operator()(const T&)` + * @tparam Hash The type of a function object capable of hashing + * values of type `T`. + * @tparam Equal The type of a function object capable of comparing + * values of type `T`. + * @tparam MemoryPolicy Memory management policy. See @ref + * memory_policy. + * + * @rst + * + * This container is based on the `immer::map` underlying data structure. + * + * This container provides a good trade-off between cache locality, + * search, update performance and structural sharing. It does so by + * storing the data in contiguous chunks of :math:`2^{B}` elements. + * When storing big objects, the size of these contiguous chunks can + * become too big, damaging performance. If this is measured to be + * problematic for a specific use-case, it can be solved by using a + * `immer::box` to wrap the type `T`. + * + * **Example** + * .. literalinclude:: ../example/table/intro.cpp + * :language: c++ + * :start-after: intro/start + * :end-before: intro/end + * + * @endrst + * + */ +template >, + typename Equal = std::equal_to>, + typename MemoryPolicy = default_memory_policy, + detail::hamts::bits_t B = default_bits> +class table +{ + using K = table_key_t; + using value_t = T; + + using move_t = + std::integral_constant; + + struct project_value + { + const T& operator()(const value_t& v) const noexcept { return v; } + T&& operator()(value_t&& v) const noexcept { return std::move(v); } + }; + + struct project_value_ptr + { + const T* operator()(const value_t& v) const noexcept + { + return std::addressof(v); + } + }; + + struct combine_value + { + template + auto operator()(Kf&& k, Tf&& v) const + { + return KeyFn{}(std::forward(v), std::forward(k)); + } + }; + + struct default_value + { + const T& operator()() const + { + static T v{}; + return v; + } + }; + + struct error_value + { + const T& operator()() const + { + IMMER_THROW(std::out_of_range{"key not found"}); + } + }; + + struct hash_key + { + std::size_t operator()(const value_t& v) const + { + return Hash{}(KeyFn{}(v)); + } + + template + std::size_t operator()(const Key& v) const + { + return Hash{}(v); + } + }; + + struct equal_key + { + bool operator()(const value_t& a, const value_t& b) const + { + auto ke = KeyFn{}; + return Equal{}(ke(a), ke(b)); + } + + template + bool operator()(const value_t& a, const Key& b) const + { + return Equal{}(KeyFn{}(a), b); + } + }; + + struct equal_value + { + bool operator()(const value_t& a, const value_t& b) const + { + return a == b; + } + }; + + using impl_t = + detail::hamts::champ; + +public: + using key_type = K; + using mapped_type = T; + using value_type = T; + using size_type = detail::hamts::size_t; + using diference_type = std::ptrdiff_t; + using hasher = Hash; + using key_equal = Equal; + using reference = const value_type&; + using const_reference = const value_type&; + + using iterator = detail::hamts:: + champ_iterator; + using const_iterator = iterator; + + using transient_type = + table_transient; + + using memory_policy_type = MemoryPolicy; + + /*! + * Constructs a table containing the elements in `values`. + */ + table(std::initializer_list values) + : impl_{impl_t::from_initializer_list(values)} + {} + + /*! + * Constructs a table containing the elements in the range + * defined by the input iterator `first` and range sentinel `last`. + */ + template , + bool> = true> + table(Iter first, Sent last) + : impl_{impl_t::from_range(first, last)} + {} + + /*! + * Default constructor. It creates a table of `size() == 0`. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + table() = default; + + /*! + * Returns an iterator pointing at the first element of the + * collection. It does not allocate memory and its complexity is + * @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator begin() const { return {impl_}; } + + /*! + * Returns an iterator pointing just after the last element of the + * collection. It does not allocate and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator end() const + { + return {impl_, typename iterator::end_t{}}; + } + + /*! + * Returns the number of elements in the container. It does + * not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type size() const { return impl_.size; } + + /*! + * Returns `true` if there are no elements in the container. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD bool empty() const { return impl_.size == 0; } + + /*! + * Returns `1` when the key `k` is contained in the table or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD size_type count(const Key& k) const + { + return impl_.template get, + detail::constantly>(k); + } + + /*! + * Returns `1` when the key `k` is contained in the table or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type count(const K& k) const + { + return impl_.template get, + detail::constantly>(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, it returns a + * default constructed value. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T& operator[](const Key& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, it returns a + * default constructed value. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD const T& operator[](const K& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, throws an + * `std::out_of_range` error. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + const T& at(const Key& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, throws an + * `std::out_of_range` error. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + const T& at(const K& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a pointer to the value associated with the key `k`. + * If there is no entry with such a key in the table, + * a `nullptr` is returned. It does not allocate memory and + * its complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD const T* find(const K& k) const + { + return impl_.template get>(k); + } + + /*! + * Returns a pointer to the value associated with the key `k`. + * If there is no entry with such a key in the table, + * a `nullptr` is returned. It does not allocate memory and + * its complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T* find(const Key& k) const + { + return impl_.template get>(k); + } + + IMMER_NODISCARD bool operator==(const table& other) const + { + return impl_.template equals(other.impl_); + } + + IMMER_NODISCARD bool operator!=(const table& other) const + { + return !(*this == other); + } + + /*! + * Returns a table containing the `value`. + * If there is an entry with its key is already, + * it replaces this entry by `value`. + * It may allocate memory and its complexity is *effectively* @f$ + * O(1) @f$. + */ + IMMER_NODISCARD table insert(value_type value) const& + { + return impl_.add(std::move(value)); + } + + /*! + * Returns a table containing the `value`. + * If there is an entry with its key is already, + * it replaces this entry by `value`. + * It may allocate memory and its complexity is *effectively* @f$ + * O(1) @f$. + */ + IMMER_NODISCARD decltype(auto) insert(value_type value) && + { + return insert_move(move_t{}, std::move(value)); + } + + /*! + * Returns `this->insert(fn((*this)[k]))`. In particular, `fn` maps + * `T` to `T`. The key `k` will be replaced inside the value returned by + * `fn`. It may allocate memory and its complexity is *effectively* @f$ O(1) + * @f$. + */ + template + IMMER_NODISCARD table update(key_type k, Fn&& fn) const& + { + return impl_ + .template update( + std::move(k), std::forward(fn)); + } + template + IMMER_NODISCARD decltype(auto) update(key_type k, Fn&& fn) && + { + return update_move(move_t{}, std::move(k), std::forward(fn)); + } + + /*! + * Returns `this.count(k) ? this->insert(fn((*this)[k])) : *this`. In + * particular, `fn` maps `T` to `T`. The key `k` will be replaced inside the + * value returned by `fn`. It may allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + template + IMMER_NODISCARD table update_if_exists(key_type k, Fn&& fn) const& + { + return impl_.template update_if_exists( + std::move(k), std::forward(fn)); + } + template + IMMER_NODISCARD decltype(auto) update_if_exists(key_type k, Fn&& fn) && + { + return update_if_exists_move( + move_t{}, std::move(k), std::forward(fn)); + } + + /*! + * Returns a table without entries with given key `k`. If the key is not + * present it returns `*this`. It may allocate + * memory and its complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD table erase(const K& k) const& { return impl_.sub(k); } + + /*! + * Returns a table without entries with given key `k`. If the key is not + * present it returns `*this`. It may allocate + * memory and its complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD decltype(auto) erase(const K& k) && + { + return erase_move(move_t{}, k); + } + + /*! + * Returns a @a transient form of this container, an + * `immer::table_transient`. + */ + IMMER_NODISCARD transient_type transient() const& + { + return transient_type{impl_}; + } + + /*! + * Returns a @a transient form of this container, an + * `immer::table_transient`. + */ + IMMER_NODISCARD transient_type transient() && + { + return transient_type{std::move(impl_)}; + } + + // Semi-private + const impl_t& impl() const { return impl_; } + +private: + friend transient_type; + + table&& insert_move(std::true_type, value_type value) + { + impl_.add_mut({}, std::move(value)); + return std::move(*this); + } + table insert_move(std::false_type, value_type value) + { + return impl_.add(std::move(value)); + } + + template + table&& update_move(std::true_type, key_type k, Fn&& fn) + { + impl_.template update_mut( + {}, std::move(k), std::forward(fn)); + return std::move(*this); + } + template + table update_move(std::false_type, key_type k, Fn&& fn) + { + return impl_ + .template update( + std::move(k), std::forward(fn)); + } + + template + table&& update_if_exists_move(std::true_type, key_type k, Fn&& fn) + { + impl_.template update_if_exists_mut( + {}, std::move(k), std::forward(fn)); + return std::move(*this); + } + template + table update_if_exists_move(std::false_type, key_type k, Fn&& fn) + { + return impl_.template update_if_exists( + std::move(k), std::forward(fn)); + } + + table&& erase_move(std::true_type, const key_type& value) + { + impl_.sub_mut({}, value); + return std::move(*this); + } + table erase_move(std::false_type, const key_type& value) + { + return impl_.sub(value); + } + + table(impl_t impl) + : impl_(std::move(impl)) + {} + + impl_t impl_ = impl_t::empty(); +}; + +} // namespace immer diff --git a/immer/table_transient.hpp b/immer/table_transient.hpp new file mode 100644 index 00000000..30b0a8c6 --- /dev/null +++ b/immer/table_transient.hpp @@ -0,0 +1,281 @@ +#pragma once + +#include +#include +#include + +namespace immer { + +template +class table; + +/*! + * Mutable version of `immer::table`. + * + * @rst + * + * Refer to :doc:`transients` to learn more about when and how to use + * the mutable versions of immutable containers. + * + * @endrst + */ +template +class table_transient : MemoryPolicy::transience_t::owner +{ + using K = std::decay_t()))>; + using base_t = typename MemoryPolicy::transience_t::owner; + using owner_t = base_t; + +public: + using persistent_type = table; + using key_type = K; + using mapped_type = T; + using value_type = T; + using size_type = detail::hamts::size_t; + using diference_type = std::ptrdiff_t; + using hasher = Hash; + using key_equal = Equal; + using reference = const value_type&; + using const_reference = const value_type&; + + using iterator = typename persistent_type::iterator; + using const_iterator = iterator; + + /*! + * Default constructor. It creates a table of `size() == 0`. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + table_transient() = default; + + /*! + * Returns an iterator pointing at the first element of the + * collection. It does not allocate memory and its complexity is + * @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator begin() const { return {impl_}; } + + /*! + * Returns an iterator pointing just after the last element of the + * collection. It does not allocate and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD iterator end() const + { + return {impl_, typename iterator::end_t{}}; + } + + /*! + * Returns the number of elements in the container. It does + * not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type size() const { return impl_.size; } + + /*! + * Returns `true` if there are no elements in the container. It + * does not allocate memory and its complexity is @f$ O(1) @f$. + */ + IMMER_NODISCARD bool empty() const { return impl_.size == 0; } + + /*! + * Returns `1` when the key `k` is contained in the table or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD size_type count(const Key& k) const + { + return impl_.template get, + detail::constantly>(k); + } + + /*! + * Returns `1` when the key `k` is contained in the table or `0` + * otherwise. It won't allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD size_type count(const K& k) const + { + return impl_.template get, + detail::constantly>(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, it returns a + * default constructed value. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T& operator[](const Key& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, it returns a + * default constructed value. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD const T& operator[](const K& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, throws an + * `std::out_of_range` error. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + const T& at(const Key& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a `const` reference to the values associated to the key + * `k`. If there is no entry with such a key in the table, throws an + * `std::out_of_range` error. It does not allocate memory and its + * complexity is *effectively* @f$ O(1) @f$. + */ + const T& at(const K& k) const + { + return impl_.template get(k); + } + + /*! + * Returns a pointer to the value associated with the key `k`. + * If there is no entry with such a key in the table, + * a `nullptr` is returned. It does not allocate memory and + * its complexity is *effectively* @f$ O(1) @f$. + */ + IMMER_NODISCARD const T* find(const K& k) const + { + return impl_.template get>(k); + } + + /*! + * Returns a pointer to the value associated with the key `k`. + * If there is no entry with such a key in the table, + * a `nullptr` is returned. It does not allocate memory and + * its complexity is *effectively* @f$ O(1) @f$. + * + * This overload participates in overload resolution only if + * `Hash::is_transparent` is valid and denotes a type. + */ + template + IMMER_NODISCARD const T* find(const Key& k) const + { + return impl_.template get>(k); + } + + /*! + * Inserts `value` to the table. + * If there is an entry with its key is already, + * it replaces this entry by `value`. + * It may allocate memory and its complexity is *effectively* @f$ + * O(1) @f$. + */ + void insert(value_type value) { impl_.add_mut(*this, std::move(value)); } + + /*! + * Returns `this->insert(fn((*this)[k]))`. In particular, `fn` maps `T` to + * `T`. The key `k` will be set into the value returned bu `fn`. It may + * allocate memory and its complexity is *effectively* @f$ O(1) @f$. + */ + template + void update(key_type k, Fn&& fn) + { + impl_.template update_mut( + *this, std::move(k), std::forward(fn)); + } + + /*! + * Returns `this->insert(fn((*this)[k]))` when `this->count(k) > 0`. In + * particular, `fn` maps `T` to `T`. The key `k` will be replaced into the + * value returned by `fn`. It may allocate memory and its complexity is + * *effectively* @f$ O(1) @f$. + */ + template + void update_if_exists(key_type k, Fn&& fn) + { + impl_.template update_if_exists_mut< + typename persistent_type::project_value, + typename persistent_type::combine_value>( + *this, std::move(k), std::forward(fn)); + } + + /*! + * Removes table entry by given key `k` if there is any. It may allocate + * memory and its complexity is *effectively* @f$ O(1) @f$. + */ + void erase(const K& k) { impl_.sub_mut(*this, k); } + + /*! + * Returns an @a immutable form of this container, an + * `immer::table`. + */ + IMMER_NODISCARD persistent_type persistent() & + { + this->owner_t::operator=(owner_t{}); + return impl_; + } + + /*! + * Returns an @a immutable form of this container, an + * `immer::table`. + */ + IMMER_NODISCARD persistent_type persistent() && { return std::move(impl_); } + +private: + friend persistent_type; + using impl_t = typename persistent_type::impl_t; + + table_transient(impl_t impl) + : impl_(std::move(impl)) + {} + + impl_t impl_ = impl_t::empty(); + +public: + // Semi-private + const impl_t& impl() const { return impl_; } +}; + +} // namespace immer diff --git a/immer/transience/gc_transience_policy.hpp b/immer/transience/gc_transience_policy.hpp index 3dafa7ca..61727870 100644 --- a/immer/transience/gc_transience_policy.hpp +++ b/immer/transience/gc_transience_policy.hpp @@ -40,6 +40,9 @@ struct gc_transience_policy struct edit { void* v; + edit(void* v_) + : v{v_} + {} edit() = delete; edit(void *v_) : v(v_) {} bool operator==(edit x) const { return v == x.v; } diff --git a/immer/vector.hpp b/immer/vector.hpp index a8310bf7..8c8ab05d 100644 --- a/immer/vector.hpp +++ b/immer/vector.hpp @@ -40,7 +40,7 @@ class vector_transient; * * @rst * - * This cotainer provides a good trade-off between cache locality, + * This container provides a good trade-off between cache locality, * random access, update performance and structural sharing. It does * so by storing the data in contiguous chunks of :math:`2^{BL}` * elements. By default, when ``sizeof(T) == sizeof(void*)`` then @@ -340,6 +340,17 @@ class vector IMMER_NODISCARD transient_type transient() const& { return impl_; } IMMER_NODISCARD transient_type transient() && { return std::move(impl_); } + /*! + * Returns a value that can be used as identity for the container. If two + * values have the same identity, they are guaranteed to be equal and to + * contain the same objects. However, two equal containers are not + * guaranteed to have the same identity. + */ + std::pair identity() const + { + return {impl_.root, impl_.tail}; + } + // Semi-private const impl_t& impl() const { return impl_; } diff --git a/nix/benchmarks.nix b/nix/benchmarks.nix index 9eaa87e2..905ff034 100644 --- a/nix/benchmarks.nix +++ b/nix/benchmarks.nix @@ -15,7 +15,7 @@ rec { }; nativeBuildInputs = [ autoreconfHook ]; propagatedBuildInputs = [ boehmgc ]; - meta = with stdenv.lib; { + meta = with lib; { homepage = "http://hypirion.com/thesis"; description = "RRB-tree implemented as a library in C. "; license = licenses.mit; @@ -34,7 +34,7 @@ rec { }; dontBuild = true; installPhase = "mkdir -vp $out/include; cp -vr $src/steady $out/include/"; - meta = with stdenv.lib; { + meta = with lib; { homepage = "https://github.com/marcusz/steady"; description = "This is a fast and reliable persistent (immutable) vector class for C++"; license = licenses.asl20; @@ -53,7 +53,7 @@ rec { }; dontBuild = true; installPhase = "mkdir -vp $out/include/chunkedseq; cp -vr $src/include/* $out/include/chunkedseq/"; - meta = with stdenv.lib; { + meta = with lib; { homepage = "http://deepsea.inria.fr/chunkedseq"; description = "Container data structure for representing sequences by many fixed-capacity heap-allocated buffers--chunks"; license = licenses.mit; @@ -72,7 +72,7 @@ rec { }; dontBuild = true; installPhase = "mkdir -vp $out/include; cp -vr $src/immutable $out/include/"; - meta = with stdenv.lib; { + meta = with lib; { homepage = "https://github.com/rsms/immutable-cpp"; description = "Persistent immutable data structures for C++"; license = licenses.mit; @@ -91,7 +91,7 @@ rec { }; dontBuild = true; installPhase = "mkdir -vp $out/include; cp -vr $src/hash_trie.hpp $out/include/"; - meta = with stdenv.lib; { + meta = with lib; { homepage = "https://github.com/rsms/immutable-cpp"; description = "Persistent immutable data structures for C++"; license = licenses.mit; diff --git a/shell.nix b/shell.nix index dde64cd7..1dfbe1eb 100644 --- a/shell.nix +++ b/shell.nix @@ -1,10 +1,12 @@ { toolchain ? "", - nixpkgs ? (import {}).fetchFromGitHub { - owner = "NixOS"; - repo = "nixpkgs"; - rev = "053ad4e0db7241ae6a02394d62750fdc5d64aa9f"; - sha256 = "11l9sr8zg8j1n5p43zjkqwpj59gn8c84z1kf16icnsbnv2smzqdc"; - }}: + rev ? "08ef0f28e3a41424b92ba1d203de64257a9fca6a", + sha256 ? "1mql1gp86bk6pfsrp0lcww6hw5civi6f8542d4nh356506jdxmcy", + nixpkgs ? builtins.fetchTarball { + name = "nixpkgs-${rev}"; + url = "https://github.com/nixos/nixpkgs/archive/${rev}.tar.gz"; + sha256 = sha256; + }, +}: with import nixpkgs {}; @@ -26,6 +28,8 @@ let if toolchain == "gnu-7" then { stdenv = gcc7Stdenv; cc = gcc7; } else if toolchain == "gnu-8" then { stdenv = gcc8Stdenv; cc = gcc8; } else if toolchain == "gnu-9" then { stdenv = gcc9Stdenv; cc = gcc9; } else + if toolchain == "gnu-10" then { stdenv = gcc10Stdenv; cc = gcc10; } else + if toolchain == "gnu-11" then { stdenv = gcc11Stdenv; cc = gcc11; } else if toolchain == "llvm-39" then { stdenv = llvmPackages_39.libcxxStdenv; cc = llvmPackages_39.libcxxClang; } else if toolchain == "llvm-4" then { stdenv = llvmPackages_4.libcxxStdenv; cc = llvmPackages_4.libcxxClang; } else if toolchain == "llvm-5" then { stdenv = llvmPackages_5.libcxxStdenv; cc = llvmPackages_5.libcxxClang; } else @@ -34,6 +38,9 @@ let if toolchain == "llvm-8" then { stdenv = llvmPackages_8.libcxxStdenv; cc = llvmPackages_8.libcxxClang; } else if toolchain == "llvm-9" then { stdenv = llvmPackages_9.stdenv; cc = llvmPackages_9.clang; } else if toolchain == "llvm-10" then { stdenv = llvmPackages_10.stdenv; cc = llvmPackages_10.clang; } else + if toolchain == "llvm-11" then { stdenv = llvmPackages_11.stdenv; cc = llvmPackages_11.clang; } else + if toolchain == "llvm-12" then { stdenv = llvmPackages_12.stdenv; cc = llvmPackages_12.clang; } else + if toolchain == "llvm-13" then { stdenv = llvmPackages_13.stdenv; cc = llvmPackages_13.clang; } else abort "unknown toolchain"; in @@ -42,6 +49,7 @@ tc.stdenv.mkDerivation rec { buildInputs = [ tc.cc git + catch2 cmake pkgconfig ninja @@ -51,6 +59,7 @@ tc.stdenv.mkDerivation rec { boost boehmgc fmt + valgrind benchmarks.c_rrb benchmarks.steady benchmarks.chunkedseq diff --git a/spm.cpp b/spm.cpp new file mode 100644 index 00000000..17c88eb3 --- /dev/null +++ b/spm.cpp @@ -0,0 +1,4 @@ + +#include + +// Just so we can compile with SPM. diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 4528a157..7fec6adb 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -16,8 +16,7 @@ foreach(_file IN LISTS immer_unit_tests) add_dependencies(tests ${_target}) target_compile_definitions(${_target} PUBLIC -DIMMER_OSS_FUZZ_DATA_PATH="${CMAKE_CURRENT_SOURCE_DIR}/oss-fuzz/data" - DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN CATCH_CONFIG_MAIN) - target_link_libraries(${_target} PUBLIC immer-dev) + target_link_libraries(${_target} PUBLIC immer-dev Catch2::Catch2) add_test("test/${_output}" ${_output}) endforeach() diff --git a/test/algorithm.cpp b/test/algorithm.cpp new file mode 100644 index 00000000..6a785dbd --- /dev/null +++ b/test/algorithm.cpp @@ -0,0 +1,221 @@ +#include +#include +#include +#include +#include +#include + +#include + +#include + +struct thing +{ + int id = 0; +}; +bool operator==(const thing& a, const thing& b) { return a.id == b.id; } + +TEST_CASE("iteration exposes const") +{ + auto do_check = [](auto v) { + using value_t = typename decltype(v)::value_type; + immer::for_each(v, [](auto&& x) { + static_assert(std::is_same::value, ""); + }); + }; + + do_check(immer::vector{}); + do_check(immer::flex_vector{}); + do_check(immer::array{}); + do_check(immer::map{}); + do_check(immer::set{}); + do_check(immer::table{}); +} + +TEST_CASE("chunked iteration exposes const") +{ + auto do_check = [](auto v) { + using value_t = typename decltype(v)::value_type; + immer::for_each_chunk(v, [](auto a, auto b) { + static_assert(std::is_same::value, ""); + static_assert(std::is_same::value, ""); + }); + }; + + do_check(immer::vector{}); + do_check(immer::flex_vector{}); + do_check(immer::array{}); + do_check(immer::map{}); + do_check(immer::set{}); + do_check(immer::table{}); +} + +TEST_CASE("accumulate") +{ + auto do_check = [](auto v) { + using value_t = typename decltype(v)::value_type; + immer::accumulate(v, value_t{}, [](auto&& a, auto&& b) { + static_assert(std::is_same::value, ""); + static_assert(std::is_same::value, ""); + return std::move(a); + }); + }; + + do_check(immer::vector{}); + do_check(immer::flex_vector{}); + do_check(immer::array{}); + do_check(immer::map{}); + do_check(immer::set{}); + do_check(immer::table{}); +} + +TEST_CASE("diffing exposes const") +{ + auto do_check = [](auto v) { + using value_t = typename decltype(v)::value_type; + immer::diff( + v, + v, + [](auto&& x) { + static_assert(std::is_same::value, + ""); + }, + [](auto&& x) { + static_assert(std::is_same::value, + ""); + }, + [](auto&& x, auto&& y) { + static_assert(std::is_same::value, + ""); + static_assert(std::is_same::value, + ""); + }); + }; + + do_check(immer::map{}); + do_check(immer::set{}); + do_check(immer::table{}); +} + +TEST_CASE("all_of") +{ + auto do_check = [](auto v) { + using value_t = typename decltype(v)::value_type; + immer::all_of(v, [](auto&& x) { + static_assert(std::is_same::value, ""); + return true; + }); + }; + + do_check(immer::vector{}); + do_check(immer::flex_vector{}); + do_check(immer::array{}); + // not supported + // do_check(immer::map{}); + // do_check(immer::set{}); + // do_check(immer::table{}); +} + +TEST_CASE("update vectors") +{ + auto do_check = [](auto v) { + if (false) + (void) v.update(0, [](auto&& x) { + using type_t = std::decay_t; + // vectors do copy first the whole array, and then move the + // copied value into the function + static_assert(std::is_same::value, ""); + return x; + }); + }; + + do_check(immer::vector{}); + do_check(immer::flex_vector{}); + do_check(immer::array{}); +} + +TEST_CASE("update maps") +{ + auto do_check = [](auto v) { + (void) v.update(0, [](auto&& x) { + using type_t = std::decay_t; + // for maps, we actually do not make a copy at all but pase the + // original instance directly, as const.. + static_assert(std::is_same::value, ""); + return x; + }); + }; + + do_check(immer::map{}); + do_check(immer::table{}); +} + +TEST_CASE("update_if_exists maps") +{ + auto do_check = [](auto v) { + (void) v.update_if_exists(0, [](auto&& x) { + using type_t = std::decay_t; + // for maps, we actually do not make a copy at all but pase the + // original instance directly, as const.. + static_assert(std::is_same::value, ""); + return x; + }); + }; + + do_check(immer::map{}); + do_check(immer::table{}); +} + +TEST_CASE("update vectors move") +{ + auto do_check = [](auto v) { + if (false) + (void) std::move(v).update(0, [](auto&& x) { + using type_t = std::decay_t; + // vectors do copy first the whole array, and then move the + // copied value into the function + static_assert(std::is_same::value, ""); + return x; + }); + }; + + do_check(immer::vector{}); + do_check(immer::flex_vector{}); + do_check(immer::array{}); +} + +TEST_CASE("update maps move") +{ + auto do_check = [](auto v) { + (void) std::move(v).update(0, [](auto&& x) { + using type_t = std::decay_t; + // for maps, we actually do not make a copy at all but pase the + // original instance directly, as const.. + static_assert(std::is_same::value || + std::is_same::value, + ""); + return x; + }); + }; + + do_check(immer::map{}); + do_check(immer::table{}); +} + +TEST_CASE("update_if_exists maps move") +{ + auto do_check = [](auto v) { + (void) std::move(v).update_if_exists(0, [](auto&& x) { + using type_t = std::decay_t; + // for maps, we actually do not make a copy at all but pase the + // original instance directly, as const.. + static_assert(std::is_same::value || + std::is_same::value, + ""); + return x; + }); + }; + + do_check(immer::map{}); + do_check(immer::table{}); +} diff --git a/test/array_transient/default.cpp b/test/array_transient/default.cpp index aa603c7b..cfa789b3 100644 --- a/test/array_transient/default.cpp +++ b/test/array_transient/default.cpp @@ -14,6 +14,10 @@ #include "../vector_transient/generic.ipp" +IMMER_RANGES_CHECK(std::ranges::contiguous_range>); +IMMER_RANGES_CHECK( + std::ranges::contiguous_range>); + TEST_CASE("array_transient default constructor compiles") { immer::array_transient transient; diff --git a/test/atom/generic.ipp b/test/atom/generic.ipp index 21ff74d7..648da315 100644 --- a/test/atom/generic.ipp +++ b/test/atom/generic.ipp @@ -10,7 +10,7 @@ #error "define the box template to use in ATOM_T" #endif -#include +#include template using BOX_T = typename ATOM_T::box_type; diff --git a/test/box/generic.ipp b/test/box/generic.ipp index cfb5f04e..72ab9c8b 100644 --- a/test/box/generic.ipp +++ b/test/box/generic.ipp @@ -10,7 +10,7 @@ #error "define the box template to use in BOX_T" #endif -#include +#include TEST_CASE("construction and copy") { @@ -34,6 +34,91 @@ TEST_CASE("equality") CHECK(x != BOX_T{42}); } +struct counters +{ + unsigned construct = 0; + unsigned copy = 0; + unsigned compare = 0; + + static counters* p_; + struct scope + { + scope(counters* p) + { + assert(p == p_ || !p_); + p_ = p; + } + ~scope() { p_ = nullptr; } + }; + scope use() { return {this}; } +}; +counters* counters::p_ = nullptr; + +template +struct spionage +{ + T value = {}; + + spionage() + : value{} + { + ++counters::p_->construct; + } + spionage(T v) + : value{v} + { + ++counters::p_->construct; + } + spionage(const spionage& v) + : value{v.value} + { + ++counters::p_->copy; + } + spionage(spionage&& v) + : value{std::move(v.value)} + { + ++counters::p_->copy; + } + bool operator==(const spionage& b) const + { + ++counters::p_->compare; + return value == b.value; + } + bool operator!=(const spionage& b) const + { + ++counters::p_->compare; + return value != b.value; + } + bool operator==(const T& b) const + { + ++counters::p_->compare; + return value == b; + } + bool operator!=(const T& b) const + { + ++counters::p_->compare; + return value != b; + } +}; + +TEST_CASE("equality not too much construction") +{ + auto c = counters{}; + auto s = c.use(); + + auto x = BOX_T>{}; + auto y = x; + CHECK(x == 0.0f); + CHECK(x == y); + CHECK(c.copy == 0); + CHECK(c.construct == 1); + + CHECK(x == BOX_T>{}); + CHECK(x != BOX_T>{42}); + CHECK(c.copy == 0); + CHECK(c.construct == 3); +} + TEST_CASE("update") { auto x = BOX_T{}; diff --git a/test/box/recursive.cpp b/test/box/recursive.cpp index 4c8fce07..46d12043 100644 --- a/test/box/recursive.cpp +++ b/test/box/recursive.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include struct rec_vec { diff --git a/test/box/vector-of-boxes-transient.cpp b/test/box/vector-of-boxes-transient.cpp index 623c8ba3..399be547 100644 --- a/test/box/vector-of-boxes-transient.cpp +++ b/test/box/vector-of-boxes-transient.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include TEST_CASE("issue-33") { diff --git a/test/detail/type_traits.cpp b/test/detail/type_traits.cpp index 8809418c..632a25c9 100644 --- a/test/detail/type_traits.cpp +++ b/test/detail/type_traits.cpp @@ -6,7 +6,7 @@ // See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt // -#include +#include #include #include #include diff --git a/test/experimental/dvektor.cpp b/test/experimental/dvektor.cpp index 437384a7..ffdd2e0f 100644 --- a/test/experimental/dvektor.cpp +++ b/test/experimental/dvektor.cpp @@ -15,7 +15,7 @@ #include #include -#include +#include using namespace immer; @@ -27,7 +27,7 @@ TEST_CASE("instantiation") TEST_CASE("push back one element") { - SUBCASE("one element") + SECTION("one element") { const auto v1 = dvektor{}; auto v2 = v1.push_back(42); @@ -36,7 +36,7 @@ TEST_CASE("push back one element") CHECK(v2[0] == 42); } - SUBCASE("many elements") + SECTION("many elements") { const auto n = 666u; auto v = dvektor{}; @@ -56,7 +56,7 @@ TEST_CASE("update") for (auto i = 0u; i < n; ++i) v = v.push_back(i); - SUBCASE("assoc") + SECTION("assoc") { const auto u = v.assoc(3u, 13u); CHECK(u.size() == v.size()); @@ -67,7 +67,7 @@ TEST_CASE("update") CHECK(v[3u] == 3u); } - SUBCASE("assoc further") + SECTION("assoc further") { for (auto i = n; i < 666; ++i) v = v.push_back(i); @@ -88,7 +88,7 @@ TEST_CASE("update") CHECK(v[200u] == 200u); } - SUBCASE("assoc further more") + SECTION("assoc further more") { auto v = immer::dvektor{}; @@ -101,7 +101,7 @@ TEST_CASE("update") } } - SUBCASE("update") + SECTION("update") { const auto u = v.update(10u, [](auto x) { return x + 10; }); CHECK(u.size() == v.size()); @@ -123,13 +123,13 @@ TEST_CASE("big") for (auto i = 0u; i < n; ++i) v = v.push_back(i); - SUBCASE("read") + SECTION("read") { for (auto i = 0u; i < n; ++i) CHECK(v[i] == i); } - SUBCASE("assoc") + SECTION("assoc") { for (auto i = 0u; i < n; ++i) { v = v.assoc(i, i + 1); @@ -146,7 +146,7 @@ TEST_CASE("iterator") for (auto i = 0u; i < n; ++i) v = v.push_back(i); - SUBCASE("works with range loop") + SECTION("works with range loop") { auto i = 0u; for (const auto& x : v) @@ -154,16 +154,16 @@ TEST_CASE("iterator") CHECK(i == v.size()); } - SUBCASE("works with standard algorithms") + SECTION("works with standard algorithms") { auto s = std::vector(n); std::iota(s.begin(), s.end(), 0u); std::equal(v.begin(), v.end(), s.begin(), s.end()); } - SUBCASE("can go back from end") { CHECK(n - 1 == *--v.end()); } + SECTION("can go back from end") { CHECK(n - 1 == *--v.end()); } - SUBCASE("works with reversed range adaptor") + SECTION("works with reversed range adaptor") { auto r = v | boost::adaptors::reversed; auto i = n; @@ -171,7 +171,7 @@ TEST_CASE("iterator") CHECK(x == --i); } - SUBCASE("works with strided range adaptor") + SECTION("works with strided range adaptor") { auto r = v | boost::adaptors::strided(5); auto i = 0u; @@ -179,14 +179,14 @@ TEST_CASE("iterator") CHECK(x == 5 * i++); } - SUBCASE("works reversed") + SECTION("works reversed") { auto i = n; for (auto iter = v.rbegin(), last = v.rend(); iter != last; ++iter) CHECK(*iter == --i); } - SUBCASE("advance and distance") + SECTION("advance and distance") { auto i1 = v.begin(); auto i2 = i1 + 100; diff --git a/test/flex_vector/fuzzed-0.cpp b/test/flex_vector/fuzzed-0.cpp index 7bf283d8..ed0c5a66 100644 --- a/test/flex_vector/fuzzed-0.cpp +++ b/test/flex_vector/fuzzed-0.cpp @@ -8,7 +8,7 @@ #include "extra/fuzzer/fuzzer_input.hpp" #include -#include +#include #include #include @@ -174,7 +174,7 @@ TEST_CASE("bug: concatenate too big vectors") var4 = var4.push_back(42); } -#if __GNUC__ != 9 && __GNUC__ != 8 +#ifndef IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG // Assertion `!p->relaxed()' failed SECTION("") { diff --git a/test/flex_vector/fuzzed-1.cpp b/test/flex_vector/fuzzed-1.cpp index 0eb25e72..162c78eb 100644 --- a/test/flex_vector/fuzzed-1.cpp +++ b/test/flex_vector/fuzzed-1.cpp @@ -8,7 +8,7 @@ #include "extra/fuzzer/fuzzer_input.hpp" #include -#include +#include #include #include @@ -159,7 +159,7 @@ TEST_CASE("bug: memory leak because of move update") var0 = std::move(var0).push_back(21); } -#if __GNUC__ != 9 && __GNUC__ != 8 +#if !IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { constexpr std::uint8_t input[] = { @@ -263,7 +263,8 @@ TEST_CASE("non-bug: crash") var4 = var4 + var4; var4 = var4.update(4, [](auto x) { return x + 1; }); } -#if __GNUC__ != 9 && __GNUC__ != 8 + +#ifndef IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { constexpr std::uint8_t input[] = { diff --git a/test/flex_vector/fuzzed-2.cpp b/test/flex_vector/fuzzed-2.cpp index 2ca33b12..a058ad61 100644 --- a/test/flex_vector/fuzzed-2.cpp +++ b/test/flex_vector/fuzzed-2.cpp @@ -8,7 +8,7 @@ #include "extra/fuzzer/fuzzer_input.hpp" #include -#include +#include #include #include @@ -172,7 +172,7 @@ TEST_CASE("bug: use after free on move-take") var0 = std::move(var0).take(68); } -#if __GNUC__ != 9 && __GNUC__ != 8 +#ifndef IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { constexpr std::uint8_t input[] = { diff --git a/test/flex_vector/fuzzed-3.cpp b/test/flex_vector/fuzzed-3.cpp index 6b020e6b..422497d3 100644 --- a/test/flex_vector/fuzzed-3.cpp +++ b/test/flex_vector/fuzzed-3.cpp @@ -8,7 +8,7 @@ #include "extra/fuzzer/fuzzer_input.hpp" #include -#include +#include #include #include @@ -205,7 +205,7 @@ TEST_CASE("bug: concat with moving the right side") var0 = var0 + std::move(var1); } -#if __GNUC__ != 9 && __GNUC__ != 8 +#ifndef IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("vm") { constexpr std::uint8_t input[] = { diff --git a/test/flex_vector/fuzzed-4.cpp b/test/flex_vector/fuzzed-4.cpp index 3df3c6fb..0a726bef 100644 --- a/test/flex_vector/fuzzed-4.cpp +++ b/test/flex_vector/fuzzed-4.cpp @@ -8,7 +8,7 @@ #include "extra/fuzzer/fuzzer_input.hpp" #include -#include +#include #include #include #include @@ -231,7 +231,7 @@ TEST_CASE("bug: concatenating transients") t1.append(t0); } -#if __GNUC__ != 9 && __GNUC__ != 8 +#if !IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { constexpr std::uint8_t input[] = { @@ -271,7 +271,7 @@ TEST_CASE("bug: concatenating moved transients") t2.append(std::move(t0)); } -#if __GNUC__ != 9 && __GNUC__ != 8 +#ifndef IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { constexpr std::uint8_t input[] = { @@ -309,7 +309,7 @@ TEST_CASE("bug: concatenating moved transients") t0 = {}; } -#if __GNUC__ != 9 && __GNUC__ != 8 +#if !IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { return; @@ -348,7 +348,7 @@ TEST_CASE("bug: aegsdas") t1 = {}; } -#if __GNUC__ != 9 && __GNUC__ != 8 +#ifndef IMMER_DISABLE_FUZZER_DUE_TO_GCC_BUG SECTION("") { constexpr std::uint8_t input[] = { diff --git a/test/flex_vector/generic.ipp b/test/flex_vector/generic.ipp index 6dbd73f0..f01f48ca 100644 --- a/test/flex_vector/generic.ipp +++ b/test/flex_vector/generic.ipp @@ -14,7 +14,7 @@ #include #include -#include +#include #include #include @@ -29,6 +29,9 @@ #error "define the vector template to use in VECTOR_T" #endif +IMMER_RANGES_CHECK( + std::ranges::random_access_range>); + template > auto make_test_flex_vector(unsigned min, unsigned max) { @@ -106,6 +109,18 @@ TEST_CASE("push_front") } } +TEST_CASE("random_access iteration") +{ + auto v = make_test_flex_vector(0, 10); + auto iter = v.begin(); + CHECK(*iter == 0); + CHECK(iter[0] == 0); + CHECK(iter[3] == 3); + CHECK(iter[9] == 9); + iter += 4; + CHECK(iter[-4] == 0); +} + TEST_CASE("concat") { #if IMMER_SLOW_TESTS @@ -260,27 +275,27 @@ TEST_CASE("accumulate relaxed") auto v = make_test_flex_vector_front(0, n); { auto sum = immer::accumulate(begin(v) + 100, begin(v) + 300, 0u); - CHECK(sum == expected_i(100, 300)); + CHECK(sum == expected_i(100u, 300u)); } { auto sum = immer::accumulate(begin(v) + 31, begin(v) + 300, 0u); - CHECK(sum == expected_i(31, 300)); + CHECK(sum == expected_i(31u, 300u)); } { auto sum = immer::accumulate(begin(v), begin(v) + 33, 0u); - CHECK(sum == expected_i(0, 33)); + CHECK(sum == expected_i(0u, 33u)); } { auto sum = immer::accumulate(begin(v) + 100, begin(v) + 660, 0u); - CHECK(sum == expected_i(100, 660)); + CHECK(sum == expected_i(100u, 660u)); } { auto sum = immer::accumulate(begin(v) + 100, begin(v) + 105, 0u); - CHECK(sum == expected_i(100, 105)); + CHECK(sum == expected_i(100u, 105u)); } { auto sum = immer::accumulate(begin(v) + 660, begin(v) + 664, 0u); - CHECK(sum == expected_i(660, 664)); + CHECK(sum == expected_i(660u, 664u)); } } } diff --git a/test/flex_vector/issue-45.cpp b/test/flex_vector/issue-45.cpp index 76bd77b2..3ff670e7 100644 --- a/test/flex_vector/issue-45.cpp +++ b/test/flex_vector/issue-45.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include #if IMMER_CXX_STANDARD >= 17 diff --git a/test/flex_vector_transient/generic.ipp b/test/flex_vector_transient/generic.ipp index 8c93cd16..200e7d0a 100644 --- a/test/flex_vector_transient/generic.ipp +++ b/test/flex_vector_transient/generic.ipp @@ -14,7 +14,7 @@ #include #include -#include +#include #include #include @@ -33,6 +33,11 @@ #error "define the vector template to use in VECTOR_T" #endif +IMMER_RANGES_CHECK( + std::ranges::random_access_range>); +IMMER_RANGES_CHECK( + std::ranges::random_access_range>); + template > auto make_test_flex_vector(unsigned min, unsigned max) { diff --git a/test/map/default.cpp b/test/map/default.cpp index cb453c4f..71567c23 100644 --- a/test/map/default.cpp +++ b/test/map/default.cpp @@ -6,6 +6,8 @@ // See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt // +#define IMMER_DEBUG_STATS 1 + #include #define MAP_T ::immer::map diff --git a/test/map/gc.cpp b/test/map/gc.cpp index 9a4eaebd..26646ee2 100644 --- a/test/map/gc.cpp +++ b/test/map/gc.cpp @@ -23,4 +23,5 @@ template ; #define MAP_T test_map_t +#define IMMER_IS_LIBGC_TEST 1 #include "generic.ipp" diff --git a/test/map/generic.ipp b/test/map/generic.ipp index e0fdaced..e9b6cf58 100644 --- a/test/map/generic.ipp +++ b/test/map/generic.ipp @@ -13,15 +13,21 @@ #endif #include +#include #include "test/dada.hpp" #include "test/util.hpp" -#include +#include #include +#include #include +IMMER_RANGES_CHECK(std::ranges::forward_range>); + +using memory_policy_t = MAP_T::memory_policy_type; + template auto make_generator() { @@ -66,7 +72,7 @@ auto make_test_map(unsigned n) { auto s = MAP_T{}; for (auto i = 0u; i < n; ++i) - s = s.insert({i, i}); + s = std::move(s).insert({i, i}); return s; } @@ -74,7 +80,7 @@ auto make_test_map(const std::vector>& vals) { auto s = MAP_T{}; for (auto&& v : vals) - s = s.insert(v); + s = std::move(s).insert(v); return s; } @@ -84,6 +90,7 @@ TEST_CASE("instantiation") { auto v = MAP_T{}; CHECK(v.size() == 0u); + CHECK(v.identity() == MAP_T{}.identity()); } } @@ -102,6 +109,19 @@ TEST_CASE("basic insertion") CHECK(v3.count(42) == 1); } +TEST_CASE("initializer list and range constructors") +{ + auto v0 = std::unordered_map{ + {{"foo", 42}, {"bar", 13}, {"baz", 18}, {"zab", 64}}}; + auto v1 = MAP_T{ + {{"foo", 42}, {"bar", 13}, {"baz", 18}, {"zab", 64}}}; + auto v2 = MAP_T{v0.begin(), v0.end()}; + CHECK(v1.size() == 4); + CHECK(v1.count(std::string{"foo"}) == 1); + CHECK(v1.at(std::string{"bar"}) == 13); + CHECK(v1 == v2); +} + TEST_CASE("accessor") { const auto n = 666u; @@ -121,8 +141,8 @@ TEST_CASE("at") CHECK(v.at(42) == 42); CHECK(v.at(665) == 665); #ifndef IMMER_NO_EXCEPTIONS - CHECK_THROWS_AS(v.at(666), std::out_of_range&); - CHECK_THROWS_AS(v.at(1234), std::out_of_range&); + CHECK_THROWS_AS(v.at(666), std::out_of_range); + CHECK_THROWS_AS(v.at(1234), std::out_of_range); #endif } @@ -151,7 +171,38 @@ TEST_CASE("equals and setting") CHECK(v.set(1234, 42) == v.insert({1234, 42})); CHECK(v.update(1234, [](auto&& x) { return x + 1; }) == v.set(1234, 1)); CHECK(v.update(42, [](auto&& x) { return x + 1; }) == v.set(42, 43)); + + CHECK(v.update_if_exists(1234, [](auto&& x) { return x + 1; }) == v); + CHECK(v.update_if_exists(42, [](auto&& x) { return x + 1; }) == + v.set(42, 43)); + + CHECK(v.update_if_exists(1234, [](auto&& x) { return x + 1; }).identity() == + v.identity()); + CHECK(v.update_if_exists(42, [](auto&& x) { return x + 1; }).identity() != + v.set(42, 43).identity()); + +#if IMMER_DEBUG_STATS + std::cout << (v.impl().get_debug_stats() + v.impl().get_debug_stats()) + .get_summary(); +#endif +} + +#if IMMER_DEBUG_STATS +TEST_CASE("debug stats") +{ + { + std::cout + << immer::map{}.impl().get_debug_stats().get_summary(); + } + { + immer::map map; + for (int i = 0; i <= 10; i++) { + map = std::move(map).set(i, i); + } + std::cout << map.impl().get_debug_stats().get_summary(); + } } +#endif TEST_CASE("iterator") { @@ -216,11 +267,157 @@ TEST_CASE("update a lot") { auto v = make_test_map(666u); - for (decltype(v.size()) i = 0; i < v.size(); ++i) { - v = v.update(i, [](auto&& x) { return x + 1; }); - CHECK(v[i] == i + 1); + SECTION("immutable") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = v.update(i, [](auto&& x) { return x + 1; }); + CHECK(v[i] == i + 1); + } + } + SECTION("move") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = std::move(v).update(i, [](auto&& x) { return x + 1; }); + CHECK(v[i] == i + 1); + } + } + + SECTION("erase") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = std::move(v).erase(i); + CHECK(v.count(i) == 0); + } + } +} + +TEST_CASE("update_if_exists a lot") +{ + auto v = make_test_map(666u); + + SECTION("immutable") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = v.update_if_exists(i, [](auto&& x) { return x + 1; }); + CHECK(v[i] == i + 1); + } + } + SECTION("move") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = std::move(v).update_if_exists(i, + [](auto&& x) { return x + 1; }); + CHECK(v[i] == i + 1); + } + } +} + +#if !IMMER_IS_LIBGC_TEST +TEST_CASE("update boxed move string") +{ + constexpr auto N = 666u; + constexpr auto S = 7; + auto s = MAP_T>{}; + SECTION("preserve immutability") + { + auto s0 = s; + auto i0 = 0u; + // insert + for (auto i = 0u; i < N; ++i) { + if (i % S == 0) { + s0 = s; + i0 = i; + } + s = std::move(s).update(std::to_string(i), + [&](auto&&) { return std::to_string(i); }); + { + CHECK(s.size() == i + 1); + for (auto j : test_irange(0u, i + 1)) { + CHECK(s.count(std::to_string(j)) == 1); + CHECK(*s.find(std::to_string(j)) == std::to_string(j)); + } + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(std::to_string(j)) == 0); + } + { + CHECK(s0.size() == i0); + for (auto j : test_irange(0u, i0)) { + CHECK(s0.count(std::to_string(j)) == 1); + CHECK(*s0.find(std::to_string(j)) == std::to_string(j)); + } + for (auto j : test_irange(i0, N)) + CHECK(s0.count(std::to_string(j)) == 0); + } + } + // update + for (auto i = 0u; i < N; ++i) { + if (i % S == 0) { + s0 = s; + i0 = i; + } + s = std::move(s).update(std::to_string(i), [&](auto&&) { + return std::to_string(i + 1); + }); + { + CHECK(s.size() == N); + for (auto j : test_irange(0u, i + 1)) + CHECK(*s.find(std::to_string(j)) == std::to_string(j + 1)); + for (auto j : test_irange(i + 1u, N)) + CHECK(*s.find(std::to_string(j)) == std::to_string(j)); + } + { + CHECK(s0.size() == N); + for (auto j : test_irange(0u, i0)) + CHECK(*s0.find(std::to_string(j)) == std::to_string(j + 1)); + for (auto j : test_irange(i0, N)) + CHECK(*s0.find(std::to_string(j)) == std::to_string(j)); + } + } + } +} +#endif + +#if !IMMER_IS_LIBGC_TEST +TEST_CASE("update_if_exists boxed move string") +{ + constexpr auto N = 666u; + constexpr auto S = 7; + auto s = MAP_T>{}; + SECTION("preserve immutability") + { + auto s0 = s; + auto i0 = 0u; + // insert + for (auto i = 0u; i < N; ++i) { + s = std::move(s).set(std::to_string(i), std::to_string(i)); + } + // update + for (auto i = 0u; i < N; ++i) { + if (i % S == 0) { + s0 = s; + i0 = i; + } + s = std::move(s).update_if_exists(std::to_string(i), [&](auto&&) { + return std::to_string(i + 1); + }); + { + CHECK(s.size() == N); + for (auto j : test_irange(0u, i + 1)) + CHECK(*s.find(std::to_string(j)) == std::to_string(j + 1)); + for (auto j : test_irange(i + 1u, N)) + CHECK(*s.find(std::to_string(j)) == std::to_string(j)); + } + { + CHECK(s0.size() == N); + for (auto j : test_irange(0u, i0)) + CHECK(*s0.find(std::to_string(j)) == std::to_string(j + 1)); + for (auto j : test_irange(i0, N)) + CHECK(*s0.find(std::to_string(j)) == std::to_string(j)); + } + } } } +#endif TEST_CASE("exception safety") { @@ -231,12 +428,12 @@ TEST_CASE("exception safety") using dadaist_conflictor_map_t = typename dadaist_wrapper< MAP_T>::type; - SECTION("update collisions") + SECTION("update") { auto v = dadaist_map_t{}; auto d = dadaism{}; for (auto i = 0u; i < n; ++i) - v = v.set(i, i); + v = std::move(v).set(i, i); for (auto i = 0u; i < v.size();) { try { auto s = d.next(); @@ -252,6 +449,27 @@ TEST_CASE("exception safety") IMMER_TRACE_E(d.happenings); } + SECTION("update_if_exists") + { + auto v = dadaist_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).set(i, i); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = v.update_if_exists(i, [](auto x) { return x + 1; }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(i) == i + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(i) == i); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + SECTION("update collisisions") { auto vals = make_values_with_collisions(n); @@ -273,22 +491,165 @@ TEST_CASE("exception safety") CHECK(d.happenings > 0); IMMER_TRACE_E(d.happenings); } + + SECTION("update_if_exists collisisions") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = v.insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = v.update_if_exists(vals[i].first, + [](auto x) { return x + 1; }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first) == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first) == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + + SECTION("set collisisions") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = v.insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + auto x = vals[i].second; + v = v.set(vals[i].first, x + 1); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first) == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first) == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + + SECTION("set collisisions move") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = v.insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + auto x = vals[i].second; + v = std::move(v).set(vals[i].first, x + 1); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first) == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first) == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + + SECTION("update collisisions move") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = std::move(v).update(vals[i].first, + [](auto x) { return x + 1; }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first) == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first) == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + + SECTION("update_if_exists collisisions move") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = std::move(v).update_if_exists(vals[i].first, + [](auto x) { return x + 1; }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first) == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first) == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + + SECTION("erase collisisions move") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + // auto s = d.next(); + v = std::move(v).erase(vals[i].first); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.count(vals[i].first) == 0); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first) == vals[i].second); + } + CHECK(d.happenings == 0); + IMMER_TRACE_E(d.happenings); + } } namespace { -struct KeyType { - explicit KeyType(unsigned v) : value(v) {} +struct KeyType +{ + explicit KeyType(unsigned v) + : value(v) + {} unsigned value; }; -struct LookupType { - explicit LookupType(unsigned v) : value(v) {} +struct LookupType +{ + explicit LookupType(unsigned v) + : value(v) + {} unsigned value; }; struct TransparentHash { - using hash_type = std::hash; + using hash_type = std::hash; using is_transparent = void; size_t operator()(KeyType const& k) const { return hash_type{}(k.value); } @@ -298,27 +659,28 @@ struct TransparentHash } }; -bool operator==(KeyType const& k, KeyType const& l) { +bool operator==(KeyType const& k, KeyType const& l) +{ return k.value == l.value; } -bool operator==(KeyType const& k, LookupType const& l) { +bool operator==(KeyType const& k, LookupType const& l) +{ return k.value == l.value; } -} +} // namespace TEST_CASE("lookup with transparent hash") { SECTION("default") { auto m = MAP_T>{}; - m = m.insert({KeyType{1}, 12}); + m = m.insert({KeyType{1}, 12}); auto const& v = m.at(LookupType{1}); CHECK(v == 12); } } - namespace { class KElem @@ -356,3 +718,75 @@ TEST_CASE("issue 134") } } // namespace + +void test_diff(unsigned old_num, + unsigned add_num, + unsigned remove_num, + unsigned change_num) +{ + auto values = make_values_with_collisions(old_num + add_num); + std::vector> initial_values( + values.begin(), values.begin() + old_num); + std::vector> new_values( + values.begin() + old_num, values.end()); + auto map = make_test_map(initial_values); + + std::vector old_keys; + for (auto const& val : map) + old_keys.push_back(val.first); + + auto first_snapshot = map; + CHECK(old_num == first_snapshot.size()); + + // remove + auto shuffle = old_keys; + std::random_shuffle(shuffle.begin(), shuffle.end()); + std::vector remove_keys(shuffle.begin(), + shuffle.begin() + remove_num); + std::vector rest_keys(shuffle.begin() + remove_num, + shuffle.end()); + + using key_set = std::unordered_set; + key_set removed_keys(remove_keys.begin(), remove_keys.end()); + for (auto const& key : remove_keys) + map = map.erase(key); + CHECK(old_num - remove_num == map.size()); + + // add + key_set added_keys; + for (auto const& data : new_values) { + map = map.set(data.first, data.second); + added_keys.insert(data.first); + } + + // change + key_set changed_keys; + for (auto i = 0u; i < change_num; i++) { + auto key = rest_keys[i]; + map = map.update(key, [](auto val) { return ++val; }); + changed_keys.insert(key); + } + + diff( + first_snapshot, + map, + [&](auto const& data) { REQUIRE(added_keys.erase(data.first) > 0); }, + [&](auto const& data) { REQUIRE(removed_keys.erase(data.first) > 0); }, + [&](auto const& old_data, auto const& new_data) { + (void) old_data; + REQUIRE(changed_keys.erase(new_data.first) > 0); + }); + + CHECK(added_keys.empty()); + CHECK(changed_keys.empty()); + CHECK(removed_keys.empty()); +} + +TEST_CASE("diff") +{ + test_diff(16, 10, 10, 3); + test_diff(100, 10, 10, 10); + test_diff(1500, 10, 1000, 100); + test_diff(16, 1500, 10, 3); + test_diff(100, 0, 0, 50); +} diff --git a/test/map/issue-56.cpp b/test/map/issue-56.cpp index 447c623d..8658121c 100644 --- a/test/map/issue-56.cpp +++ b/test/map/issue-56.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include TEST_CASE("const map") { diff --git a/test/map_transient/B3.cpp b/test/map_transient/B3.cpp new file mode 100644 index 00000000..d08ab916 --- /dev/null +++ b/test/map_transient/B3.cpp @@ -0,0 +1,28 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +template , + typename Eq = std::equal_to> +using test_map_t = immer::map; + +template , + typename Eq = std::equal_to> +using test_map_transient_t = + immer::map_transient; + +#define MAP_T test_map_t +#define MAP_TRANSIENT_T test_map_transient_t + +#include "generic.ipp" diff --git a/test/map_transient/B6.cpp b/test/map_transient/B6.cpp new file mode 100644 index 00000000..84a732c5 --- /dev/null +++ b/test/map_transient/B6.cpp @@ -0,0 +1,28 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +template , + typename Eq = std::equal_to> +using test_map_t = immer::map; + +template , + typename Eq = std::equal_to> +using test_map_transient_t = + immer::map_transient; + +#define MAP_T test_map_t +#define MAP_TRANSIENT_T test_map_transient_t + +#include "generic.ipp" diff --git a/test/map_transient/default.cpp b/test/map_transient/default.cpp new file mode 100644 index 00000000..7454f4f2 --- /dev/null +++ b/test/map_transient/default.cpp @@ -0,0 +1,15 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +#define MAP_T ::immer::map +#define MAP_TRANSIENT_T ::immer::map_transient + +#include "generic.ipp" diff --git a/test/map_transient/gc.cpp b/test/map_transient/gc.cpp new file mode 100644 index 00000000..2708cb19 --- /dev/null +++ b/test/map_transient/gc.cpp @@ -0,0 +1,36 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include +#include +#include + +using gc_memory = immer::memory_policy, + immer::no_refcount_policy, + immer::default_lock_policy, + immer::gc_transience_policy, + false>; + +template , + typename Eq = std::equal_to> +using test_map_t = immer::map; + +template , + typename Eq = std::equal_to> +using test_map_transient_t = + immer::map_transient; + +#define MAP_T test_map_t +#define MAP_TRANSIENT_T test_map_transient_t + +#include "generic.ipp" diff --git a/test/map_transient/generic.ipp b/test/map_transient/generic.ipp new file mode 100644 index 00000000..5d0a1540 --- /dev/null +++ b/test/map_transient/generic.ipp @@ -0,0 +1,116 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "test/util.hpp" + +#include + +#ifndef MAP_T +#error "define the map template to use in MAP_T" +#endif + +#ifndef MAP_TRANSIENT_T +#error "define the map template to use in MAP_TRANSIENT_T" +#endif + +IMMER_RANGES_CHECK(std::ranges::forward_range>); +IMMER_RANGES_CHECK( + std::ranges::forward_range>); + +TEST_CASE("instantiate") +{ + auto t = MAP_TRANSIENT_T{}; + auto m = MAP_T{}; + CHECK(t.persistent() == m); + CHECK(t.persistent() == m.transient().persistent()); +} + +TEST_CASE("access") +{ + auto m = MAP_T{{"foo", 12}, {"bar", 42}}; + auto t = m.transient(); + CHECK(t.size() == 2); + CHECK(t.count("foo") == 1); + CHECK(t["foo"] == 12); + CHECK(t.at("foo") == 12); + CHECK(t.find("foo") == m.find("foo")); + CHECK(std::accumulate(t.begin(), t.end(), 0, [](auto acc, auto&& x) { + return acc + x.second; + }) == 54); +} + +TEST_CASE("insert") +{ + auto t = MAP_TRANSIENT_T{}; + + t.insert({"foo", 42}); + CHECK(t["foo"] == 42); + CHECK(t.size() == 1); + + t.insert({"bar", 13}); + CHECK(t["bar"] == 13); + CHECK(t.size() == 2); + + t.insert({"foo", 6}); + CHECK(t["foo"] == 6); + CHECK(t.size() == 2); +} + +TEST_CASE("set") +{ + auto t = MAP_TRANSIENT_T{}; + + t.set("foo", 42); + CHECK(t["foo"] == 42); + CHECK(t.size() == 1); + + t.set("bar", 13); + CHECK(t["bar"] == 13); + CHECK(t.size() == 2); + + t.set("foo", 6); + CHECK(t["foo"] == 6); + CHECK(t.size() == 2); +} + +TEST_CASE("update") +{ + auto t = MAP_TRANSIENT_T{}; + + t.update("foo", [](auto x) { return x + 42; }); + CHECK(t["foo"] == 42); + CHECK(t.size() == 1); + + t.update("bar", [](auto x) { return x + 13; }); + CHECK(t["bar"] == 13); + CHECK(t.size() == 2); + + t.update("foo", [](auto x) { return x + 6; }); + CHECK(t["foo"] == 48); + CHECK(t.size() == 2); + + t.update_if_exists("foo", [](auto x) { return x + 42; }); + CHECK(t["foo"] == 90); + CHECK(t.size() == 2); + + t.update_if_exists("manolo", [](auto x) { return x + 42; }); + CHECK(t["manolo"] == 0); + CHECK(t.size() == 2); +} + +TEST_CASE("erase") +{ + auto t = MAP_T{{"foo", 12}, {"bar", 42}}.transient(); + + t.erase("foo"); + CHECK(t.find("foo") == nullptr); + CHECK(t.count("foo") == 0); + CHECK(t.find("bar") != nullptr); + CHECK(t.count("bar") == 1); + CHECK(t.size() == 1); +} diff --git a/test/memory/heaps.cpp b/test/memory/heaps.cpp index 94af2be2..a43c99b7 100644 --- a/test/memory/heaps.cpp +++ b/test/memory/heaps.cpp @@ -12,7 +12,7 @@ #include #include -#include +#include #include void do_stuff_to(void* buf, std::size_t size) diff --git a/test/memory/refcounts.cpp b/test/memory/refcounts.cpp index f9278ca7..f8a82e82 100644 --- a/test/memory/refcounts.cpp +++ b/test/memory/refcounts.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include TEST_CASE("no refcount has no data") { @@ -42,16 +42,6 @@ void test_refcount() CHECK(!elem.dec()); CHECK(elem.dec()); } - - SECTION("inc dec unsafe") - { - refcount elem{}; - elem.inc(); - CHECK(!elem.dec()); - elem.inc(); - elem.dec_unsafe(); - CHECK(elem.dec()); - } } TEST_CASE("basic refcount") { test_refcount(); } diff --git a/test/oss-fuzz/array-0.cpp b/test/oss-fuzz/array-0.cpp index d0c2962a..162b0154 100644 --- a/test/oss-fuzz/array-0.cpp +++ b/test/oss-fuzz/array-0.cpp @@ -10,7 +10,7 @@ #include -#include +#include namespace { diff --git a/test/oss-fuzz/array-gc-0.cpp b/test/oss-fuzz/array-gc-0.cpp index 40a29331..74806653 100644 --- a/test/oss-fuzz/array-gc-0.cpp +++ b/test/oss-fuzz/array-gc-0.cpp @@ -15,7 +15,7 @@ #include #include -#include +#include using gc_memory = immer::memory_policy, immer::no_refcount_policy, diff --git a/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-6457979420934144 b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-6457979420934144 new file mode 100644 index 00000000..3165e60d Binary files /dev/null and b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-6457979420934144 differ diff --git a/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-st-5313188008165376 b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-st-5313188008165376 new file mode 100644 index 00000000..290b5da0 Binary files /dev/null and b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-st-5313188008165376 differ diff --git a/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-st-6242663155761152 b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-st-6242663155761152 new file mode 100644 index 00000000..3cdc39d0 Binary files /dev/null and b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-map-st-6242663155761152 differ diff --git a/test/oss-fuzz/data/clusterfuzz-testcase-minimized-set-st-4717454829420544 b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-set-st-4717454829420544 new file mode 100644 index 00000000..dd17c1f5 --- /dev/null +++ b/test/oss-fuzz/data/clusterfuzz-testcase-minimized-set-st-4717454829420544 @@ -0,0 +1 @@ +   � \ No newline at end of file diff --git a/test/oss-fuzz/data/crash-2838943da19b47c02dcff313e523eead0e2e8635 b/test/oss-fuzz/data/crash-2838943da19b47c02dcff313e523eead0e2e8635 new file mode 100644 index 00000000..d9acbc51 Binary files /dev/null and b/test/oss-fuzz/data/crash-2838943da19b47c02dcff313e523eead0e2e8635 differ diff --git a/test/oss-fuzz/data/crash-dc9dad6beae69a6bb8ffd6d203b95032f445ec9b b/test/oss-fuzz/data/crash-dc9dad6beae69a6bb8ffd6d203b95032f445ec9b new file mode 100644 index 00000000..b39c03e1 Binary files /dev/null and b/test/oss-fuzz/data/crash-dc9dad6beae69a6bb8ffd6d203b95032f445ec9b differ diff --git a/test/oss-fuzz/flex-vector-0.cpp b/test/oss-fuzz/flex-vector-0.cpp index f29eeb9f..2ce52917 100644 --- a/test/oss-fuzz/flex-vector-0.cpp +++ b/test/oss-fuzz/flex-vector-0.cpp @@ -12,12 +12,12 @@ #include #include -#include +#include #define IMMER_FUZZED_TRACE_ENABLE 0 #if IMMER_FUZZED_TRACE_ENABLE -#include +#include #define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__) #else #define IMMER_FUZZED_TRACE(...) diff --git a/test/oss-fuzz/flex-vector-bo-0.cpp b/test/oss-fuzz/flex-vector-bo-0.cpp index b821734f..f9526cac 100644 --- a/test/oss-fuzz/flex-vector-bo-0.cpp +++ b/test/oss-fuzz/flex-vector-bo-0.cpp @@ -12,12 +12,12 @@ #include #include -#include +#include #define IMMER_FUZZED_TRACE_ENABLE 1 #if IMMER_FUZZED_TRACE_ENABLE -#include +#include #define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__) #else #define IMMER_FUZZED_TRACE(...) diff --git a/test/oss-fuzz/flex-vector-gc-0.cpp b/test/oss-fuzz/flex-vector-gc-0.cpp index 75dd1ae1..0b9e6d6a 100644 --- a/test/oss-fuzz/flex-vector-gc-0.cpp +++ b/test/oss-fuzz/flex-vector-gc-0.cpp @@ -13,12 +13,12 @@ #include #include -#include +#include #define IMMER_FUZZED_TRACE_ENABLE 0 #if IMMER_FUZZED_TRACE_ENABLE -#include +#include #define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__) #else #define IMMER_FUZZED_TRACE(...) diff --git a/test/oss-fuzz/map-gc-0.cpp b/test/oss-fuzz/map-gc-0.cpp index a97baf7d..fd0540da 100644 --- a/test/oss-fuzz/map-gc-0.cpp +++ b/test/oss-fuzz/map-gc-0.cpp @@ -14,7 +14,7 @@ #include #include -#include +#include using gc_memory = immer::memory_policy, immer::no_refcount_policy, diff --git a/test/oss-fuzz/map-st-0.cpp b/test/oss-fuzz/map-st-0.cpp index 4435fb04..59aa0c6f 100644 --- a/test/oss-fuzz/map-st-0.cpp +++ b/test/oss-fuzz/map-st-0.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include using st_memory = immer::memory_policy, immer::unsafe_refcount_policy, @@ -111,3 +111,13 @@ TEST_CASE("https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=24466") CHECK(run_input(input.data(), input.size()) == 0); } } + +TEST_CASE("https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=47700") +{ + SECTION("fuzzer") + { + auto input = + load_input("clusterfuzz-testcase-minimized-map-6457979420934144"); + CHECK(run_input(input.data(), input.size()) == 0); + } +} diff --git a/test/oss-fuzz/map-st-1.cpp b/test/oss-fuzz/map-st-1.cpp new file mode 100644 index 00000000..4041ea96 --- /dev/null +++ b/test/oss-fuzz/map-st-1.cpp @@ -0,0 +1,134 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "input.hpp" + +#include "extra/fuzzer/fuzzer_gc_guard.hpp" + +#include +#include +#include + +#include + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(std::size_t x) const { return x & ~15; } +}; + +namespace { + +int run_input(const std::uint8_t* data, std::size_t size) +{ + constexpr auto var_count = 4; + + using map_t = immer:: + map, st_memory>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_set, + op_erase, + op_set_move, + op_erase_move, + op_iterate, + op_find, + op_update, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + switch (read(in)) { + case op_set: { + auto value = read(in); + vars[dst] = vars[src].set(value, 42); + break; + } + case op_erase: { + auto value = read(in); + vars[dst] = vars[src].erase(value); + break; + } + case op_set_move: { + auto value = read(in); + vars[dst] = std::move(vars[src]).set(value, 42); + break; + } + case op_erase_move: { + auto value = read(in); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].set(v.first, v.second); + } + break; + } + case op_find: { + auto value = read(in); + auto res = vars[src].find(value); + if (res != nullptr) { + vars[dst] = vars[dst].set(*res, 42); + } + break; + } + case op_update: { + auto key = read(in); + vars[dst] = vars[src].update(key, [](int x) { return x + 1; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } + default: + break; + }; + return true; + }); +} + +} // namespace + +TEST_CASE("https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=48207") +{ + SECTION("fuzzer") + { + auto input = load_input( + "clusterfuzz-testcase-minimized-map-st-5313188008165376"); + CHECK(run_input(input.data(), input.size()) == 0); + } +} diff --git a/test/oss-fuzz/map-st-2.cpp b/test/oss-fuzz/map-st-2.cpp new file mode 100644 index 00000000..782e2af4 --- /dev/null +++ b/test/oss-fuzz/map-st-2.cpp @@ -0,0 +1,201 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "input.hpp" + +#include "extra/fuzzer/fuzzer_gc_guard.hpp" + +#include +#include +#include + +#include + +#define IMMER_FUZZED_TRACE_ENABLE 0 + +#if IMMER_FUZZED_TRACE_ENABLE +#include +#define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__) +#else +#define IMMER_FUZZED_TRACE(...) +#endif + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(std::size_t x) const { return x & ~15; } +}; + +namespace { + +int run_input(const std::uint8_t* data, std::size_t size) +{ + constexpr auto var_count = 4; + + using map_t = immer:: + map, st_memory>; + + auto vars = std::array{}; + +#if IMMER_FUZZED_TRACE_ENABLE + IMMER_FUZZED_TRACE("/// new test run\n"); + IMMER_FUZZED_TRACE("using map_t = immer::map," + "immer::default_memory_policy, {}>;\n", + immer::default_bits); + for (auto i = 0u; i < var_count; ++i) + IMMER_FUZZED_TRACE("auto v{} = map_t{{}};\n", i); +#endif + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_set, + op_erase, + op_set_move, + op_erase_move, + op_iterate, + op_find, + op_update, + op_update_move, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + switch (read(in)) { + case op_set: { + auto value = read(in); + IMMER_FUZZED_TRACE("v{} = v{}.set({}, 42);\n", +dst, +src, +value); + vars[dst] = vars[src].set(value, 42); + break; + } + case op_erase: { + auto value = read(in); + IMMER_FUZZED_TRACE("v{} = v{}.erase({});\n", +dst, +src, +value); + vars[dst] = vars[src].erase(value); + break; + } + case op_set_move: { + auto value = read(in); + IMMER_FUZZED_TRACE( + "v{} = std::move(v{}).set({}, 42);\n", +dst, +src, +value); + vars[dst] = std::move(vars[src]).set(value, 42); + break; + } + case op_erase_move: { + auto value = read(in); + IMMER_FUZZED_TRACE( + "v{} = std::move(v{}).erase({});\n", +dst, +src, +value); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + IMMER_FUZZED_TRACE("{auto srcv = {}; for (const auto& v : srcv) " + "v{} = v{}.set(v.first, v.second); }\n", + +dst, + +src); + for (const auto& v : srcv) { + vars[dst] = vars[dst].set(v.first, v.second); + } + break; + } + case op_find: { + auto value = read(in); + auto res = vars[src].find(value); + IMMER_FUZZED_TRACE("if (auto res = v{}.find({}); res) v{} = " + "v{}.set(*res, 42);\n", + +src, + +value, + +dst, + +dst); + if (res != nullptr) { + vars[dst] = vars[dst].set(*res, 42); + } + break; + } + case op_update: { + auto key = read(in); + IMMER_FUZZED_TRACE("v{} = v{}.update(key, [](int x) { " + "return x + 1; });\n", + +dst, + +src, + +key); + vars[dst] = vars[src].update(key, [](int x) { return x + 1; }); + break; + } + case op_update_move: { + auto key = read(in); + IMMER_FUZZED_TRACE("v{} = std::move(v{}).update(key, [](int x) { " + "return x + 1; });\n", + +dst, + +src, + +key); + vars[dst] = + std::move(vars[src]).update(key, [](int x) { return x + 1; }); + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } + default: + break; + }; + return true; + }); +} + +} // namespace + +TEST_CASE("https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=48398") +{ + SECTION("fuzzer") + { + auto input = load_input( + "clusterfuzz-testcase-minimized-map-st-6242663155761152"); + CHECK(run_input(input.data(), input.size()) == 0); + } + + SECTION("translated") + { + using map_t = immer::map, + immer::default_memory_policy, + 5>; + auto v0 = map_t{}; + auto v1 = map_t{}; + v0 = v0.set(0, 42); + v1 = v0; + v0 = std::move(v1).erase(0); + } +} diff --git a/test/oss-fuzz/map-st-str-0.cpp b/test/oss-fuzz/map-st-str-0.cpp new file mode 100644 index 00000000..fdf5204c --- /dev/null +++ b/test/oss-fuzz/map-st-str-0.cpp @@ -0,0 +1,218 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "input.hpp" + +#include +#include +#include + +#include + +#include + +#include + +#define IMMER_FUZZED_TRACE_ENABLE 1 + +#if IMMER_FUZZED_TRACE_ENABLE +#include +#define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__) +#else +#define IMMER_FUZZED_TRACE(...) +#endif + +namespace { + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(const std::string& x) const + { + return std::hash{}(x) & ~15; + } +}; + +int run_input(const std::uint8_t* data, std::size_t size) +{ + constexpr auto var_count = 4; + + using map_t = immer::map, + st_memory>; + + auto vars = std::array{}; + +#if IMMER_FUZZED_TRACE_ENABLE + IMMER_FUZZED_TRACE("/// new test run\n"); + IMMER_FUZZED_TRACE("using map_t = immer::map, st_memory>;\n"); + for (auto i = 0u; i < var_count; ++i) + IMMER_FUZZED_TRACE("auto v{} = map_t{{}};\n", i); +#endif + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_set, + op_erase, + op_set_move, + op_erase_move, + op_iterate, + op_find, + op_update, + op_update_move, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + IMMER_FUZZED_TRACE("CHECK(v{}.impl().check_champ());\n", +src); + CHECK(vars[src].impl().check_champ()); + switch (read(in)) { + case op_set: { + auto value = std::to_string(read(in)); + IMMER_FUZZED_TRACE( + "v{} = v{}.set(\"{}\", \"foo\");\n", +dst, +src, value); + vars[dst] = vars[src].set(value, "foo"); + break; + } + case op_erase: { + auto value = std::to_string(read(in)); + IMMER_FUZZED_TRACE("v{} = v{}.erase(\"{}\");\n", +dst, +src, value); + vars[dst] = vars[src].erase(value); + break; + } + case op_set_move: { + auto value = std::to_string(read(in)); + IMMER_FUZZED_TRACE("v{} = std::move(v{}).set(\"{}\", \"foo\");\n", + +dst, + +src, + value); + vars[dst] = std::move(vars[src]).set(value, "foo"); + break; + } + case op_erase_move: { + auto value = std::to_string(read(in)); + IMMER_FUZZED_TRACE( + "v{} = std::move(v{}).erase(\"{}\");\n", +dst, +src, value); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + IMMER_FUZZED_TRACE("!!!TODO;\n"); + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].set(v.first, v.second); + } + break; + } + case op_find: { + IMMER_FUZZED_TRACE("!!!TODO;\n"); + auto value = std::to_string(read(in)); + auto res = vars[src].find(value); + if (res != nullptr) { + vars[dst] = vars[dst].set(*res, "foo"); + } + break; + } + case op_update: { + auto key = std::to_string(read(in)); + IMMER_FUZZED_TRACE("v{} = v{}.update(\"{}\", [] (auto x) {{ " + "return x + \"bar\"; }});\n", + +dst, + +src, + key); + vars[dst] = vars[src].update( + key, [](std::string x) { return std::move(x) + "bar"; }); + break; + } + case op_update_move: { + auto key = std::to_string(read(in)); + IMMER_FUZZED_TRACE( + "v{} = std::move(v{}).update(\"{}\", [] (auto x) {{ " + "return x + \"bar\"; }});\n", + +dst, + +src, + key); + vars[dst] = std::move(vars[src]).update( + key, [](std::string x) { return std::move(x) + "baz"; }); + break; + } + case op_diff: { + IMMER_FUZZED_TRACE("!!!TODO;\n"); + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x.first)); + assert(b.count(x.first)); + }, + [&](auto&& x) { + assert(a.count(x.first)); + assert(!b.count(x.first)); + }, + [&](auto&& x, auto&& y) { + assert(x.first == y.first); + assert(x.second != y.second); + }); + } + default: + break; + }; + return true; + }); +} + +} // namespace + +TEST_CASE("local test runs") +{ + SECTION("fuzzer") + { + auto input = + load_input("crash-dc9dad6beae69a6bb8ffd6d203b95032f445ec9b"); + CHECK(run_input(input.data(), input.size()) == 0); + (void) run_input; + } + + SECTION("simplify") + { + using map_t = immer::map, + st_memory>; + auto v0 = map_t{}; + auto v3 = map_t{}; + + v0 = std::move(v0) + .set("256", "foo") + .set("217020539959771201", "foo") + .set("91201394110889985", "foo") + .set("217020518514230019", "foo"); + v3 = v0; + v0 = v0.set("0", "foo"); + CHECK(v0.impl().check_champ()); + CHECK(v3.impl().check_champ()); + + v3 = std::move(v3).erase("217020518514230019"); // here + CHECK(v3.impl().check_champ()); + CHECK(v0.impl().check_champ()); + } +} diff --git a/test/oss-fuzz/set-gc-0.cpp b/test/oss-fuzz/set-gc-0.cpp index 7e88b0bb..c6abebcc 100644 --- a/test/oss-fuzz/set-gc-0.cpp +++ b/test/oss-fuzz/set-gc-0.cpp @@ -14,7 +14,7 @@ #include #include -#include +#include using gc_memory = immer::memory_policy, immer::no_refcount_policy, diff --git a/test/oss-fuzz/set-gc-1.cpp b/test/oss-fuzz/set-gc-1.cpp index 19b318e6..d07901a2 100644 --- a/test/oss-fuzz/set-gc-1.cpp +++ b/test/oss-fuzz/set-gc-1.cpp @@ -16,12 +16,12 @@ #include -#include +#include #define IMMER_FUZZED_TRACE_ENABLE 0 #if IMMER_FUZZED_TRACE_ENABLE -#include +#include #define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__) #else #define IMMER_FUZZED_TRACE(...) diff --git a/test/oss-fuzz/set-st-0.cpp b/test/oss-fuzz/set-st-0.cpp new file mode 100644 index 00000000..4e56f211 --- /dev/null +++ b/test/oss-fuzz/set-st-0.cpp @@ -0,0 +1,118 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "input.hpp" + +#include +#include +#include + +#include + +#include + +#include + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(std::size_t x) const { return x & ~15; } +}; + +namespace { + +int run_input(const std::uint8_t* data, std::size_t size) +{ + constexpr auto var_count = 4; + + using set_t = + immer::set, st_memory>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_insert, + op_erase, + op_insert_move, + op_erase_move, + op_iterate, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + switch (read(in)) { + case op_insert: { + auto value = read(in); + vars[dst] = vars[src].insert(value); + break; + } + case op_erase: { + auto value = read(in); + vars[dst] = vars[src].erase(value); + break; + } + case op_insert_move: { + auto value = read(in); + vars[dst] = std::move(vars[src]).insert(value); + break; + } + case op_erase_move: { + auto value = read(in); + vars[dst] = vars[src].erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].insert(v); + } + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } + default: + break; + }; + return true; + }); +} + +} // namespace + +TEST_CASE("https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=47693") +{ + SECTION("fuzzer") + { + auto input = load_input( + "clusterfuzz-testcase-minimized-set-st-4717454829420544"); + CHECK(run_input(input.data(), input.size()) == 0); + } +} diff --git a/test/oss-fuzz/set-st-str-0.cpp b/test/oss-fuzz/set-st-str-0.cpp new file mode 100644 index 00000000..538abf70 --- /dev/null +++ b/test/oss-fuzz/set-st-str-0.cpp @@ -0,0 +1,122 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "input.hpp" + +#include +#include +#include + +#include + +#include + +#include + +namespace { + +using st_memory = immer::memory_policy, + immer::unsafe_refcount_policy, + immer::no_lock_policy, + immer::no_transience_policy, + false>; + +struct colliding_hash_t +{ + std::size_t operator()(const std::string& x) const + { + return std::hash{}(x) & ~15; + } +}; + +int run_input(const std::uint8_t* data, std::size_t size) +{ + constexpr auto var_count = 4; + + using set_t = + immer::set, st_memory>; + + auto vars = std::array{}; + + auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; }; + + return fuzzer_input{data, size}.run([&](auto& in) { + enum ops + { + op_insert, + op_erase, + op_insert_move, + op_erase_move, + op_iterate, + op_diff + }; + auto src = read(in, is_valid_var); + auto dst = read(in, is_valid_var); + assert(vars[src].impl().check_champ()); + switch (read(in)) { + case op_insert: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].insert(value); + break; + } + case op_erase: { + auto value = std::to_string(read(in)); + vars[dst] = vars[src].erase(value); + break; + } + case op_insert_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).insert(value); + break; + } + case op_erase_move: { + auto value = std::to_string(read(in)); + vars[dst] = std::move(vars[src]).erase(value); + break; + } + case op_iterate: { + auto srcv = vars[src]; + for (const auto& v : srcv) { + vars[dst] = vars[dst].insert(v); + } + break; + } + case op_diff: { + auto&& a = vars[src]; + auto&& b = vars[dst]; + diff( + a, + b, + [&](auto&& x) { + assert(!a.count(x)); + assert(b.count(x)); + }, + [&](auto&& x) { + assert(a.count(x)); + assert(!b.count(x)); + }, + [&](auto&& x, auto&& y) { assert(false); }); + } + default: + break; + }; + return true; + }); +} + +} // namespace + +TEST_CASE("local test runs") +{ + SECTION("fuzzer") + { + auto input = + load_input("crash-2838943da19b47c02dcff313e523eead0e2e8635"); + CHECK(run_input(input.data(), input.size()) == 0); + } +} diff --git a/test/set/gc.cpp b/test/set/gc.cpp index 65963d2c..e4bc47e5 100644 --- a/test/set/gc.cpp +++ b/test/set/gc.cpp @@ -22,4 +22,6 @@ template ; #define SET_T test_set_t +#define IMMER_IS_LIBGC_TEST 1 + #include "generic.ipp" diff --git a/test/set/generic.ipp b/test/set/generic.ipp index 12285f33..d8bde725 100644 --- a/test/set/generic.ipp +++ b/test/set/generic.ipp @@ -16,12 +16,18 @@ #include "test/util.hpp" #include +#include -#include +#include #include #include +using memory_policy_t = SET_T::memory_policy_type; + +IMMER_RANGES_CHECK(std::input_iterator::iterator>); +IMMER_RANGES_CHECK(std::ranges::forward_range>); + template auto make_generator() { @@ -30,6 +36,15 @@ auto make_generator() return std::bind(dist, engine); } +template +auto make_generator_s() +{ + auto engine = std::default_random_engine{42}; + auto dist = std::uniform_int_distribution{}; + return + [g = std::bind(dist, engine)]() mutable { return std::to_string(g()); }; +} + struct conflictor { unsigned v1; @@ -65,7 +80,7 @@ auto make_test_set(unsigned n) { auto s = SET_T{}; for (auto i = 0u; i < n; ++i) - s = s.insert(i); + s = std::move(s).insert(i); return s; } @@ -73,7 +88,7 @@ auto make_test_set(const std::vector& vals) { auto s = SET_T{}; for (auto&& v : vals) - s = s.insert(v); + s = std::move(s).insert(v); return s; } @@ -144,16 +159,31 @@ TEST_CASE("instantiation") } } +TEST_CASE("initializer list and range constructors") +{ + auto v0 = std::unordered_set{{"foo", "bar", "baz", "zab"}}; + auto v1 = SET_T{{"foo", "bar", "baz", "zab"}}; + auto v2 = SET_T{v0.begin(), v0.end()}; + CHECK(v1.size() == 4); + CHECK(v1.count(std::string{"foo"}) == 1); + CHECK(v1.count(std::string{"bar"}) == 1); + CHECK(v1 == v2); +} + TEST_CASE("basic insertion") { auto v1 = SET_T{}; CHECK(v1.count(42) == 0); + CHECK(v1.identity() == SET_T{}.identity()); auto v2 = v1.insert(42); CHECK(v1.count(42) == 0); CHECK(v2.count(42) == 1); + CHECK(v1.identity() != v2.identity()); auto v3 = v2.insert(42); + // it would maybe be nice if this was not the case, but it is... + CHECK(v2.identity() != v3.identity()); CHECK(v1.count(42) == 0); CHECK(v2.count(42) == 1); CHECK(v3.count(42) == 1); @@ -168,13 +198,27 @@ TEST_CASE("insert a lot") generate_n(back_inserter(vals), N, gen); auto s = SET_T{}; - for (auto i = 0u; i < N; ++i) { - s = s.insert(vals[i]); - CHECK(s.size() == i + 1); - for (auto j : test_irange(0u, i + 1)) - CHECK(s.count(vals[j]) == 1); - for (auto j : test_irange(i + 1u, N)) - CHECK(s.count(vals[j]) == 0); + SECTION("immutable") + { + for (auto i = 0u; i < N; ++i) { + s = s.insert(vals[i]); + CHECK(s.size() == i + 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 1); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 0); + } + } + SECTION("move") + { + for (auto i = 0u; i < N; ++i) { + s = std::move(s).insert(vals[i]); + CHECK(s.size() == i + 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 1); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 0); + } } } @@ -183,15 +227,64 @@ TEST_CASE("insert conflicts") constexpr auto N = 666u; auto vals = make_values_with_collisions(N); auto s = SET_T{}; - for (auto i = 0u; i < N; ++i) { - s = s.insert(vals[i]); - CHECK(s.size() == i + 1); - for (auto j : test_irange(0u, i + 1)) - CHECK(s.count(vals[j]) == 1); - for (auto j : test_irange(i + 1u, N)) - CHECK(s.count(vals[j]) == 0); + SECTION("immutable") + { + for (auto i = 0u; i < N; ++i) { + s = s.insert(vals[i]); + CHECK(s.size() == i + 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 1); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 0); + } + } + SECTION("move") + { + for (auto i = 0u; i < N; ++i) { + s = std::move(s).insert(vals[i]); + CHECK(s.size() == i + 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 1); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 0); + } + } +} + +#if !IMMER_IS_LIBGC_TEST +TEST_CASE("insert boxed move string") +{ + constexpr auto N = 666u; + constexpr auto S = 7; + auto s = SET_T>{}; + SECTION("preserve immutability") + { + auto s0 = s; + auto i0 = 0u; + for (auto i = 0u; i < N; ++i) { + if (i % S == 0) { + s0 = s; + i0 = i; + } + s = std::move(s).insert(std::to_string(i)); + { + CHECK(s.size() == i + 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(std::to_string(j)) == 1); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(std::to_string(j)) == 0); + } + { + CHECK(s0.size() == i0); + for (auto j : test_irange(0u, i0)) + CHECK(s0.count(std::to_string(j)) == 1); + for (auto j : test_irange(i0, N)) + CHECK(s0.count(std::to_string(j)) == 0); + } + } } } +#endif TEST_CASE("erase a lot") { @@ -202,33 +295,125 @@ TEST_CASE("erase a lot") auto s = SET_T{}; for (auto i = 0u; i < N; ++i) - s = s.insert(vals[i]); + s = std::move(s).insert(vals[i]); - for (auto i = 0u; i < N; ++i) { - s = s.erase(vals[i]); - CHECK(s.size() == N - i - 1); - for (auto j : test_irange(0u, i + 1)) - CHECK(s.count(vals[j]) == 0); - for (auto j : test_irange(i + 1u, N)) - CHECK(s.count(vals[j]) == 1); + SECTION("immutable") + { + for (auto i = 0u; i < N; ++i) { + s = s.erase(vals[i]); + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } + } + SECTION("move") + { + for (auto i = 0u; i < N; ++i) { + s = std::move(s).erase(vals[i]); + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } } } +#if !IMMER_IS_LIBGC_TEST +TEST_CASE("erase a lot boxed string") +{ + constexpr auto N = 666u; + auto gen = make_generator_s(); + auto vals = std::vector>{}; + generate_n(back_inserter(vals), N, gen); + + auto s = SET_T>{}; + for (auto i = 0u; i < N; ++i) + s = std::move(s).insert(vals[i]); + + SECTION("immutable") + { + for (auto i = 0u; i < N; ++i) { + s = s.erase(vals[i]); + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } + } + SECTION("move") + { + for (auto i = 0u; i < N; ++i) { + s = std::move(s).erase(vals[i]); + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } + } + SECTION("move preserve immutability") + { + constexpr auto S = 7; + auto s0 = s; + auto i0 = 0u; + for (auto i = 0u; i < N; ++i) { + if (i % S == 0) { + s0 = s; + i0 = i; + } + s = std::move(s).erase(vals[i]); + { + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } + { + CHECK(s0.size() == N - i0); + for (auto j : test_irange(0u, i0)) + CHECK(s0.count(vals[j]) == 0); + for (auto j : test_irange(i0, N)) + CHECK(s0.count(vals[j]) == 1); + } + } + } +} +#endif + TEST_CASE("erase conflicts") { constexpr auto N = 666u; auto vals = make_values_with_collisions(N); auto s = SET_T{}; for (auto i = 0u; i < N; ++i) - s = s.insert(vals[i]); + s = std::move(s).insert(vals[i]); - for (auto i = 0u; i < N; ++i) { - s = s.erase(vals[i]); - CHECK(s.size() == N - i - 1); - for (auto j : test_irange(0u, i + 1)) - CHECK(s.count(vals[j]) == 0); - for (auto j : test_irange(i + 1u, N)) - CHECK(s.count(vals[j]) == 1); + SECTION("immutable") + { + for (auto i = 0u; i < N; ++i) { + s = s.erase(vals[i]); + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } + } + SECTION("move") + { + for (auto i = 0u; i < N; ++i) { + s = std::move(s).erase(vals[i]); + CHECK(s.size() == N - i - 1); + for (auto j : test_irange(0u, i + 1)) + CHECK(s.count(vals[j]) == 0); + for (auto j : test_irange(i + 1u, N)) + CHECK(s.count(vals[j]) == 1); + } } } @@ -250,7 +435,7 @@ TEST_CASE("accumulate") auto vals = make_values_with_collisions(n); auto s = make_test_set(vals); auto acc = [](unsigned r, conflictor x) { return r + x.v1 + x.v2; }; - auto sum1 = std::accumulate(vals.begin(), vals.end(), 0, acc); + auto sum1 = std::accumulate(vals.begin(), vals.end(), 0u, acc); auto sum2 = immer::accumulate(s, 0u, acc); CHECK(sum1 == sum2); } @@ -307,6 +492,9 @@ TEST_CASE("iterator") struct non_default { unsigned value; + non_default(unsigned v) + : value{v} + {} non_default() = delete; operator unsigned() const { return value; } @@ -458,21 +646,26 @@ TEST_CASE("exception safety") } } - namespace { -struct KeyType { - explicit KeyType(unsigned v) : value(v) {} +struct KeyType +{ + explicit KeyType(unsigned v) + : value(v) + {} unsigned value; }; -struct LookupType { - explicit LookupType(unsigned v) : value(v) {} +struct LookupType +{ + explicit LookupType(unsigned v) + : value(v) + {} unsigned value; }; struct TransparentHash { - using hash_type = std::hash; + using hash_type = std::hash; using is_transparent = void; size_t operator()(KeyType const& k) const { return hash_type{}(k.value); } @@ -482,22 +675,72 @@ struct TransparentHash } }; -bool operator==(KeyType const& k, KeyType const& l) { +bool operator==(KeyType const& k, KeyType const& l) +{ return k.value == l.value; } -bool operator==(KeyType const& k, LookupType const& l) { +bool operator==(KeyType const& k, LookupType const& l) +{ return k.value == l.value; } -} +} // namespace TEST_CASE("lookup with transparent hash") { SECTION("default") { auto m = SET_T>{}; - m = m.insert(KeyType{1}); + m = m.insert(KeyType{1}); CHECK(m.count(LookupType{1}) == 1); CHECK(m.count(LookupType{2}) == 0); } } + +void test_diff(unsigned old_num, unsigned add_num, unsigned remove_num) +{ + auto values = make_values_with_collisions(old_num + add_num); + std::vector initial_values(values.begin(), + values.begin() + old_num); + std::vector new_values(values.begin() + old_num, values.end()); + auto set = make_test_set(initial_values); + + auto first_snapshot = set; + CHECK(old_num == first_snapshot.size()); + + // remove + auto shuffle = initial_values; + std::random_shuffle(shuffle.begin(), shuffle.end()); + std::vector remove_keys(shuffle.begin(), + shuffle.begin() + remove_num); + + using key_set = std::unordered_set; + key_set removed_keys(remove_keys.begin(), remove_keys.end()); + for (auto const& key : remove_keys) + set = set.erase(key); + CHECK(old_num - remove_num == set.size()); + + // add + key_set added_keys; + for (auto const& data : new_values) { + set = set.insert(data); + added_keys.insert(data); + } + + diff( + first_snapshot, + set, + [&](auto const& data) { REQUIRE(added_keys.erase(data) > 0); }, + [&](auto const& data) { REQUIRE(removed_keys.erase(data) > 0); }); + + CHECK(added_keys.empty()); + CHECK(removed_keys.empty()); +} + +TEST_CASE("diff") +{ + test_diff(16, 10, 10); + test_diff(100, 10, 10); + test_diff(1500, 10, 1000); + test_diff(16, 1500, 10); +} diff --git a/test/set/relocation.cpp b/test/set/relocation.cpp index 152d8bf2..f7f02a3c 100644 --- a/test/set/relocation.cpp +++ b/test/set/relocation.cpp @@ -6,7 +6,7 @@ // See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt // -#include +#include #include using relocation_memory = immer::memory_policy +#include + +template , + typename Eq = std::equal_to> +using test_set_t = immer::set; + +template , + typename Eq = std::equal_to> +using test_set_transient_t = + immer::set_transient; + +#define SET_T test_set_t +#define SET_TRANSIENT_T test_set_transient_t + +#include "generic.ipp" diff --git a/test/set_transient/B6.cpp b/test/set_transient/B6.cpp new file mode 100644 index 00000000..6448b101 --- /dev/null +++ b/test/set_transient/B6.cpp @@ -0,0 +1,26 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +template , + typename Eq = std::equal_to> +using test_set_t = immer::set; + +template , + typename Eq = std::equal_to> +using test_set_transient_t = + immer::set_transient; + +#define SET_T test_set_t +#define SET_TRANSIENT_T test_set_transient_t + +#include "generic.ipp" diff --git a/test/set_transient/default.cpp b/test/set_transient/default.cpp new file mode 100644 index 00000000..8b5fed4d --- /dev/null +++ b/test/set_transient/default.cpp @@ -0,0 +1,15 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +#define SET_T ::immer::set +#define SET_TRANSIENT_T ::immer::set_transient + +#include "generic.ipp" diff --git a/test/set_transient/gc.cpp b/test/set_transient/gc.cpp new file mode 100644 index 00000000..8d5543dd --- /dev/null +++ b/test/set_transient/gc.cpp @@ -0,0 +1,33 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include +#include +#include + +using gc_memory = immer::memory_policy, + immer::no_refcount_policy, + immer::default_lock_policy, + immer::gc_transience_policy, + false>; + +template , + typename Eq = std::equal_to> +using test_set_t = immer::set; + +template , + typename Eq = std::equal_to> +using test_set_transient_t = immer::set_transient; + +#define SET_T test_set_t +#define SET_TRANSIENT_T test_set_transient_t + +#include "generic.ipp" diff --git a/test/set_transient/generic.ipp b/test/set_transient/generic.ipp new file mode 100644 index 00000000..29f7b0b9 --- /dev/null +++ b/test/set_transient/generic.ipp @@ -0,0 +1,104 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "test/util.hpp" + +#include + +#ifndef SET_T +#error "define the set template to use in SET_T" +#endif + +#ifndef SET_TRANSIENT_T +#error "define the set template to use in SET_TRANSIENT_T" +#endif + +IMMER_RANGES_CHECK(std::ranges::forward_range>); +IMMER_RANGES_CHECK(std::ranges::forward_range>); + +TEST_CASE("instantiate") +{ + auto t = SET_TRANSIENT_T{}; + auto m = SET_T{}; + CHECK(t.persistent() == m); + CHECK(t.persistent() == m.transient().persistent()); +} + +TEST_CASE("access") +{ + auto m = SET_T{12, 42}; + auto t = m.transient(); + CHECK(t.size() == 2); + CHECK(t.count(42) == 1); + CHECK(*t.find(12) == 12); + CHECK(std::accumulate(t.begin(), t.end(), 0) == 54); +} + +TEST_CASE("insert") +{ + auto t = SET_TRANSIENT_T{}; + + t.insert(42); + CHECK(*t.find(42) == 42); + CHECK(t.size() == 1); + + t.insert(13); + CHECK(*t.find(13) == 13); + CHECK(t.size() == 2); + + t.insert(42); + CHECK(*t.find(42) == 42); + CHECK(t.size() == 2); +} + +TEST_CASE("erase") +{ + auto t = SET_T{12, 42}.transient(); + + t.erase(42); + CHECK(t.find(42) == nullptr); + CHECK(t.count(42) == 0); + CHECK(t.find(12) != nullptr); + CHECK(t.count(12) == 1); + CHECK(t.size() == 1); +} + +TEST_CASE("insert erase many") +{ + auto t = SET_T{}.transient(); + auto n = 1000; + for (auto i = 0; i < n; ++i) { + t.insert(i); + CHECK(t.find(i) != nullptr); + CHECK(t.size() == static_cast(i + 1)); + } + for (auto i = 0; i < n; ++i) { + t.erase(i); + CHECK(t.find(i) == nullptr); + CHECK(t.size() == static_cast(n - i - 1)); + } +} + +TEST_CASE("erase many from non transient") +{ + const auto n = 10000; + auto t = [] { + auto t = SET_T{}; + for (auto i = 0; i < n; ++i) { + t = t.insert(i); + CHECK(t.find(i) != nullptr); + CHECK(t.size() == static_cast(i + 1)); + } + return t.transient(); + }(); + for (auto i = 0; i < n; ++i) { + t.erase(i); + CHECK(t.find(i) == nullptr); + CHECK(t.size() == static_cast(n - i - 1)); + } +} diff --git a/test/table/B3.cpp b/test/table/B3.cpp new file mode 100644 index 00000000..f6327ab2 --- /dev/null +++ b/test/table/B3.cpp @@ -0,0 +1,20 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +struct setup_t +{ + using memory_policy = immer::default_memory_policy; + + static constexpr auto bits = 3u; +}; + +#define SETUP_T setup_t +#include "generic.ipp" diff --git a/test/table/B6.cpp b/test/table/B6.cpp new file mode 100644 index 00000000..910fa995 --- /dev/null +++ b/test/table/B6.cpp @@ -0,0 +1,20 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +struct setup_t +{ + using memory_policy = immer::default_memory_policy; + + static constexpr auto bits = 6u; +}; + +#define SETUP_T setup_t +#include "generic.ipp" diff --git a/test/table/default.cpp b/test/table/default.cpp new file mode 100644 index 00000000..3ea016bb --- /dev/null +++ b/test/table/default.cpp @@ -0,0 +1,20 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +struct setup_t +{ + using memory_policy = immer::default_memory_policy; + + static constexpr auto bits = immer::default_bits; +}; + +#define SETUP_T setup_t +#include "generic.ipp" diff --git a/test/table/gc.cpp b/test/table/gc.cpp new file mode 100644 index 00000000..67613474 --- /dev/null +++ b/test/table/gc.cpp @@ -0,0 +1,18 @@ +#include +#include +#include + +struct setup_t +{ + using memory_policy = + immer::memory_policy, + immer::no_refcount_policy, + immer::default_lock_policy, + immer::gc_transience_policy, + false>; + + static constexpr auto bits = immer::default_bits; +}; + +#define SETUP_T setup_t +#include "generic.ipp" diff --git a/test/table/generic.ipp b/test/table/generic.ipp new file mode 100644 index 00000000..f943e51f --- /dev/null +++ b/test/table/generic.ipp @@ -0,0 +1,570 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "immer/memory_policy.hpp" +#ifndef SETUP_T +#error "define the map template to use in MAP_T" +#endif + +#include +#include + +#include "test/dada.hpp" +#include "test/util.hpp" + +#include + +#include +#include +#include + +struct pair_key_fn +{ + template + F operator()(const std::pair& p) const + { + return p.first; + } + + template + auto operator()(std::pair p, F k) const + { + p.first = std::move(k); + return p; + } + + template + F operator()(const dadaist>& p) const + { + return p.value.first; + } + + template + auto operator()(dadaist> p, F k) const + { + p.value.first = std::move(k); + return p; + } +}; + +template , + typename Eq = std::equal_to> +using table_map = immer::table, + pair_key_fn, + Hash, + Eq, + SETUP_T::memory_policy, + SETUP_T::bits>; + +IMMER_RANGES_CHECK(std::ranges::forward_range>); + +template +auto make_generator() +{ + auto engine = std::default_random_engine{42}; + auto dist = std::uniform_int_distribution{}; + return std::bind(dist, engine); +} + +struct conflictor +{ + uint32_t v1; + uint32_t v2; + + bool operator==(const conflictor& x) const + { + return v1 == x.v1 && v2 == x.v2; + } +}; + +struct hash_conflictor +{ + std::size_t operator()(const conflictor& x) const { return x.v1; } +}; + +auto make_values_with_collisions(uint32_t n) +{ + auto gen = make_generator(); + auto vals = std::vector>{}; + auto vals_ = std::unordered_set{}; + auto i = 0u; + generate_n(back_inserter(vals), n, [&] { + auto newv = conflictor{}; + do { + newv = {uint32_t(gen() % (n / 2)), gen()}; + } while (!vals_.insert(newv).second); + return std::pair{newv, i++}; + }); + return vals; +} + +auto make_test_map(uint32_t n) +{ + auto s = table_map{}; + for (auto i = 0u; i < n; ++i) + s = std::move(s).insert({i, i}); + return s; +} + +auto make_test_map(const std::vector>& vals) +{ + auto s = table_map{}; + for (auto&& v : vals) + s = std::move(s).insert(v); + return s; +} + +TEST_CASE("instantiation") +{ + SECTION("default") + { + auto v = table_map{}; + CHECK(v.size() == 0u); + } +} + +TEST_CASE("basic insertion") +{ + auto v1 = table_map{}; + CHECK(v1.count(42) == 0); + + auto v2 = v1.insert({42, {}}); + CHECK(v1.count(42) == 0); + CHECK(v2.count(42) == 1); + + auto v3 = v2.insert({42, {}}); + CHECK(v1.count(42) == 0); + CHECK(v2.count(42) == 1); + CHECK(v3.count(42) == 1); +} + +TEST_CASE("initializer list and range constructors") +{ + auto v0 = std::unordered_map{ + {{"foo", 42}, {"bar", 13}, {"baz", 18}, {"zab", 64}}}; + auto v1 = table_map{ + {{"foo", 42}, {"bar", 13}, {"baz", 18}, {"zab", 64}}}; + auto v2 = table_map{v0.begin(), v0.end()}; + CHECK(v1.size() == 4); + CHECK(v1.count(std::string{"foo"}) == 1); + CHECK(v1.at(std::string{"bar"}).second == 13); + CHECK(v1 == v2); +} + +TEST_CASE("accessor") +{ + const auto n = 666u; + auto v = make_test_map(n); + CHECK(v[0].second == 0); + CHECK(v[42].second == 42); + CHECK(v[665].second == 665); + CHECK(v[666].second == 0); + CHECK(v[1234].second == 0); +} + +TEST_CASE("at") +{ + const auto n = 666u; + auto v = make_test_map(n); + CHECK(v.at(0).second == 0); + CHECK(v.at(42).second == 42); + CHECK(v.at(665).second == 665); +#ifndef IMMER_NO_EXCEPTIONS + CHECK_THROWS_AS(v.at(666), std::out_of_range); + CHECK_THROWS_AS(v.at(1234), std::out_of_range); +#endif +} + +TEST_CASE("find") +{ + const auto n = 666u; + auto v = make_test_map(n); + CHECK(v.find(0)->second == 0); + CHECK(v.find(42)->second == 42); + CHECK(v.find(665)->second == 665); + CHECK(v.find(666) == nullptr); + CHECK(v.find(1234) == nullptr); +} + +TEST_CASE("equals and insert") +{ + const auto n = 666u; + auto v = make_test_map(n); + + CHECK(v == v); + CHECK(v != v.insert({1234, 42})); + CHECK(v != v.erase(32)); + CHECK(v == v.insert({1234, 42}).erase(1234)); + CHECK(v == v.erase(32).insert({32, 32})); +} + +TEST_CASE("iterator") +{ + const auto N = 666u; + auto v = make_test_map(N); + + SECTION("empty set") + { + auto s = table_map{}; + CHECK(s.begin() == s.end()); + } + + SECTION("works with range loop") + { + auto seen = std::unordered_set{}; + for (const auto& x : v) + CHECK(seen.insert(x.first).second); + CHECK(seen.size() == v.size()); + } + + SECTION("iterator and collisions") + { + auto vals = make_values_with_collisions(N); + auto s = make_test_map(vals); + auto seen = std::unordered_set{}; + for (const auto& x : s) + CHECK(seen.insert(x.first).second); + CHECK(seen.size() == s.size()); + } +} + +TEST_CASE("accumulate") +{ + const auto n = 666u; + auto v = make_test_map(n); + + auto expected_n = [](auto n) { return n * (n - 1) / 2; }; + + SECTION("sum collection") + { + auto acc = [](uint32_t acc, const std::pair& x) { + return acc + x.first + x.second; + }; + auto sum = immer::accumulate(v, 0u, acc); + CHECK(sum == 2 * expected_n(v.size())); + } + + SECTION("sum collisions") + { + auto vals = make_values_with_collisions(n); + auto s = make_test_map(vals); + auto acc = [](uint32_t r, std::pair x) { + return r + x.first.v1 + x.first.v2 + x.second; + }; + auto sum1 = std::accumulate(vals.begin(), vals.end(), 0u, acc); + auto sum2 = immer::accumulate(s, 0u, acc); + CHECK(sum1 == sum2); + } +} + +TEST_CASE("update a lot") +{ + auto v = make_test_map(666u); + auto incr_id = [](auto&& p) { + return std::make_pair(p.first, p.second + 1); + }; + SECTION("immutable") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = v.update(i, incr_id); + CHECK(v[i].second == i + 1); + } + } + SECTION("move") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = std::move(v).update(i, incr_id); + CHECK(v[i].second == i + 1); + } + } + SECTION("if_exists immutable") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = v.update_if_exists(i, incr_id); + CHECK(v[i].second == i + 1); + } + } + SECTION("if_exists move") + { + for (decltype(v.size()) i = 0; i < v.size(); ++i) { + v = std::move(v).update_if_exists(i, incr_id); + CHECK(v[i].second == i + 1); + } + } +} + +TEST_CASE("exception safety") +{ + constexpr auto n = 2666u; + + using dadaist_map_t = + immer::table>, // + pair_key_fn, // + std::hash, // + std::equal_to, // + dadaist_memory_policy, // + SETUP_T::bits // + >; + + auto make_pair = [](auto f, auto s) { + return dadaist>( + std::make_pair(f, s)); + }; + SECTION("update collisions") + { + auto v = dadaist_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).insert(make_pair(i, i)); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = v.update(i, [&make_pair](auto x) { + return make_pair(x.value.first, x.value.second + 1); + }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(i).value.second == i + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(i).value.second == i); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + using dadaist_conflictor_map_t = + immer::table>, // + pair_key_fn, // + hash_conflictor, // + std::equal_to, // + dadaist_memory_policy, // + SETUP_T::bits // + >; + + SECTION("update collisisions") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = v.insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = v.update(vals[i].first, [&make_pair](auto x) { + return make_pair(x.value.first, x.value.second + 1); + }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first).value.second == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first).value.second == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + + SECTION("update collisisions move") + { + auto vals = make_values_with_collisions(n); + auto v = dadaist_conflictor_map_t{}; + auto d = dadaism{}; + for (auto i = 0u; i < n; ++i) + v = std::move(v).insert(vals[i]); + for (auto i = 0u; i < v.size();) { + try { + auto s = d.next(); + v = v.update(vals[i].first, [&make_pair](auto x) { + return make_pair(x.value.first, x.value.second + 1); + }); + ++i; + } catch (dada_error) {} + for (auto i : test_irange(0u, i)) + CHECK(v.at(vals[i].first).value.second == vals[i].second + 1); + for (auto i : test_irange(i, n)) + CHECK(v.at(vals[i].first).value.second == vals[i].second); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } +} + +namespace { + +struct KeyType +{ + explicit KeyType(uint32_t v) + : value(v) + {} + uint32_t value; +}; + +struct LookupType +{ + explicit LookupType(uint32_t v) + : value(v) + {} + uint32_t value; +}; + +struct TransparentHash +{ + using hash_type = std::hash; + using is_transparent = void; + + size_t operator()(KeyType const& k) const { return hash_type{}(k.value); } + size_t operator()(LookupType const& k) const + { + return hash_type{}(k.value); + } +}; + +bool operator==(KeyType const& k, KeyType const& l) +{ + return k.value == l.value; +} + +bool operator==(KeyType const& k, LookupType const& l) +{ + return k.value == l.value; +} + +} // namespace + +TEST_CASE("lookup with transparent hash") +{ + SECTION("default") + { + auto m = table_map>{}; + m = m.insert({KeyType{1}, 12}); + + auto const& v = m.at(LookupType{1}); + CHECK(v.second == 12); + } +} + +namespace { + +class KElem +{ +public: + KElem(int* elem) { this->elem = elem; } + + bool operator==(const KElem& other) const + { + return this->elem == other.elem; + } + + bool operator!=(const KElem& other) const { return !(*this == other); } + + int* elem; +}; + +struct HashBlock +{ + size_t operator()(const KElem& block) const noexcept + { + return (uintptr_t) block.elem & 0xffffffff00000000; + } +}; + +} // namespace + +TEST_CASE("issue 134") +{ + int a[100]; + table_map m; + for (int i = 0; i < 100; i++) { + m = m.insert({KElem(a + i), KElem(a + i)}); + } +} + +void test_diff(uint32_t old_num, + uint32_t add_num, + uint32_t remove_num, + uint32_t change_num) +{ + auto values = make_values_with_collisions(old_num + add_num); + std::vector> initial_values( + values.begin(), values.begin() + old_num); + std::vector> new_values( + values.begin() + old_num, values.end()); + auto map = make_test_map(initial_values); + + std::vector old_keys; + for (auto const& val : map) + old_keys.push_back(val.first); + + auto first_snapshot = map; + CHECK(old_num == first_snapshot.size()); + + // remove + auto shuffle = old_keys; + std::random_shuffle(shuffle.begin(), shuffle.end()); + std::vector remove_keys(shuffle.begin(), + shuffle.begin() + remove_num); + std::vector rest_keys(shuffle.begin() + remove_num, + shuffle.end()); + + using key_set = std::unordered_set; + key_set removed_keys(remove_keys.begin(), remove_keys.end()); + for (auto const& key : remove_keys) + map = map.erase(key); + CHECK(old_num - remove_num == map.size()); + + // add + key_set added_keys; + for (auto const& data : new_values) { + map = map.insert({data.first, data.second}); + added_keys.insert(data.first); + } + + // change + key_set changed_keys; + for (auto i = 0u; i < change_num; i++) { + auto key = rest_keys[i]; + map = map.update(key, [](auto val) { + return std::make_pair(val.first, val.second + 1); + }); + changed_keys.insert(key); + } + + diff( + first_snapshot, + map, + [&](auto const& data) { REQUIRE(added_keys.erase(data.first) > 0); }, + [&](auto const& data) { REQUIRE(removed_keys.erase(data.first) > 0); }, + [&](auto const& old_data, auto const& new_data) { + (void) old_data; + REQUIRE(changed_keys.erase(new_data.first) > 0); + }); + + CHECK(added_keys.empty()); + CHECK(changed_keys.empty()); + CHECK(removed_keys.empty()); +} + +TEST_CASE("diff") +{ + test_diff(16, 10, 10, 3); + test_diff(100, 10, 10, 10); + test_diff(1500, 10, 1000, 100); + test_diff(16, 1500, 10, 3); + test_diff(100, 0, 0, 50); +} + +TEST_CASE("const map") +{ + const auto x = table_map{}.insert({"A", 1}); + auto it = x.begin(); + CHECK(it->first == "A"); + CHECK(it->second == 1); +} diff --git a/test/table_transient/B3.cpp b/test/table_transient/B3.cpp new file mode 100644 index 00000000..ff9b17cf --- /dev/null +++ b/test/table_transient/B3.cpp @@ -0,0 +1,34 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +struct setup_t +{ + template + using table_transient = immer::table_transient< + T, + immer::table_key_fn, + std::hash>, + std::equal_to>, + immer::default_memory_policy, + 3u>; + + template + using table = + immer::table>, + std::equal_to>, + immer::default_memory_policy, + 3u>; +}; +#define SETUP_T setup_t + +#include "generic.ipp" diff --git a/test/table_transient/B6.cpp b/test/table_transient/B6.cpp new file mode 100644 index 00000000..8dacd058 --- /dev/null +++ b/test/table_transient/B6.cpp @@ -0,0 +1,34 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +struct setup_t +{ + template + using table_transient = immer::table_transient< + T, + immer::table_key_fn, + std::hash>, + std::equal_to>, + immer::default_memory_policy, + 6u>; + + template + using table = + immer::table>, + std::equal_to>, + immer::default_memory_policy, + 6u>; +}; +#define SETUP_T setup_t + +#include "generic.ipp" diff --git a/test/table_transient/default.cpp b/test/table_transient/default.cpp new file mode 100644 index 00000000..3ccf1ad3 --- /dev/null +++ b/test/table_transient/default.cpp @@ -0,0 +1,34 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include + +struct setup_t +{ + template + using table_transient = immer::table_transient< + T, + immer::table_key_fn, + std::hash>, + std::equal_to>, + immer::default_memory_policy, + immer::default_bits>; + + template + using table = + immer::table>, + std::equal_to>, + immer::default_memory_policy, + immer::default_bits>; +}; +#define SETUP_T setup_t + +#include "generic.ipp" diff --git a/test/table_transient/gc.cpp b/test/table_transient/gc.cpp new file mode 100644 index 00000000..47709932 --- /dev/null +++ b/test/table_transient/gc.cpp @@ -0,0 +1,42 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include +#include +#include +#include + +struct setup_t +{ + using gc_memory = immer::memory_policy, + immer::no_refcount_policy, + immer::default_lock_policy, + immer::gc_transience_policy, + false>; + + template + using table_transient = immer::table_transient< + T, + immer::table_key_fn, + std::hash>, + std::equal_to>, + gc_memory, + immer::default_bits>; + + template + using table = + immer::table>, + std::equal_to>, + gc_memory, + immer::default_bits>; +}; +#define SETUP_T setup_t + +#include "generic.ipp" diff --git a/test/table_transient/generic.ipp b/test/table_transient/generic.ipp new file mode 100644 index 00000000..73725be5 --- /dev/null +++ b/test/table_transient/generic.ipp @@ -0,0 +1,103 @@ +// +// immer: immutable data structures for C++ +// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente +// +// This software is distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt +// + +#include "test/util.hpp" + +#include + +#ifndef SETUP_T +#error "define the table types via SETUP_T macro" +#endif + +#include + +struct Item +{ + std::string id{}; + int value{}; + + bool operator==(const Item& other) const + { + return value == other.value && id == other.id; + } +}; + +IMMER_RANGES_CHECK(std::ranges::forward_range>); +IMMER_RANGES_CHECK(std::ranges::forward_range>); + +TEST_CASE("instantiate") +{ + auto t = SETUP_T::table_transient{}; + auto m = SETUP_T::table{}; + CHECK(t.persistent() == m); + CHECK(t.persistent() == m.transient().persistent()); +} + +TEST_CASE("access") +{ + auto m = SETUP_T::table{Item{"foo", 12}, Item{"bar", 42}}; + auto t = m.transient(); + CHECK(t.size() == 2); + CHECK(t.count("foo") == 1); + CHECK(t["foo"].value == 12); + CHECK(t.at("foo").value == 12); + CHECK(t.find("foo") == m.find("foo")); + CHECK(std::accumulate(t.begin(), t.end(), 0, [](auto acc, auto&& x) { + return acc + x.value; + }) == 54); +} + +TEST_CASE("insert") +{ + auto t = SETUP_T::table_transient{}; + + t.insert(Item{"foo", 42}); + CHECK(t["foo"].value == 42); + CHECK(t.size() == 1); + + t.insert(Item{"bar", 13}); + CHECK(t["bar"].value == 13); + CHECK(t.size() == 2); + + t.insert(Item{"foo", 6}); + CHECK(t["foo"].value == 6); + CHECK(t.size() == 2); + + t.update("foo", [](auto item) { + item.value += 1; + return item; + }); + CHECK(t["foo"].value == 7); + CHECK(t.size() == 2); + + t.update("lol", [](auto item) { + item.value += 1; + return item; + }); + CHECK(t["lol"].value == 1); + CHECK(t.size() == 3); + + t.update_if_exists("foo", [](auto item) { + item.value += 1; + return item; + }); + CHECK(t["foo"].value == 8); + CHECK(t.size() == 3); +} + +TEST_CASE("erase") +{ + auto t = SETUP_T::table{{"foo", 12}, {"bar", 42}}.transient(); + + t.erase("foo"); + CHECK(t.find("foo") == nullptr); + CHECK(t.count("foo") == 0); + CHECK(t.find("bar") != nullptr); + CHECK(t.count("bar") == 1); + CHECK(t.size() == 1); +} diff --git a/test/util.hpp b/test/util.hpp index 41904f5a..30100dd0 100644 --- a/test/util.hpp +++ b/test/util.hpp @@ -12,6 +12,18 @@ #include #include +#include // For __cpp_lib_ranges + +// If we have ranges, include the header for the concepts, and define +// IMMER_RANGES_CHECK() to expand to a static_assert of the argument, otherwise +// define it as a no-op static_assert. +#if __cpp_lib_ranges +#include +#define IMMER_RANGES_CHECK(...) static_assert(__VA_ARGS__) +#else +#define IMMER_RANGES_CHECK(...) static_assert(true, "") +#endif + namespace { struct identity_t diff --git a/test/vector/generic.ipp b/test/vector/generic.ipp index 777a3534..ccce07ae 100644 --- a/test/vector/generic.ipp +++ b/test/vector/generic.ipp @@ -12,7 +12,7 @@ #include #include -#include +#include #include #include @@ -25,6 +25,8 @@ using namespace std::string_literals; #error "define the vector template to use in VECTOR_T" #endif +IMMER_RANGES_CHECK(std::ranges::random_access_range>); + template > auto make_test_vector(unsigned min, unsigned max) { @@ -113,11 +115,23 @@ TEST_CASE("at") CHECK(v.at(0) == 0); CHECK(v.at(5) == 5); #ifndef IMMER_NO_EXCEPTIONS - CHECK_THROWS_AS(v.at(10), const std::out_of_range&); - CHECK_THROWS_AS(v.at(11), const std::out_of_range&); + CHECK_THROWS_AS(v.at(10), std::out_of_range); + CHECK_THROWS_AS(v.at(11), std::out_of_range); #endif } +TEST_CASE("random_access iteration") +{ + auto v = VECTOR_T{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + auto iter = v.begin(); + CHECK(*iter == 0); + CHECK(iter[0] == 0); + CHECK(iter[3] == 3); + CHECK(iter[9] == 9); + iter += 4; + CHECK(iter[-4] == 0); +} + TEST_CASE("push back one element") { SECTION("one element") @@ -127,6 +141,12 @@ TEST_CASE("push back one element") CHECK(v1.size() == 0u); CHECK(v2.size() == 1u); CHECK(v2[0] == 42); + + // basic identity rules + auto v3 = v2; + CHECK(v1.identity() != v2.identity()); + CHECK(v3.identity() == v2.identity()); + CHECK(v1.identity() == VECTOR_T{}.identity()); } SECTION("many elements") @@ -336,27 +356,27 @@ TEST_CASE("accumulate") using namespace std; { auto sum = immer::accumulate(begin(v) + 100, begin(v) + 300, 0u); - CHECK(sum == expected_i(100, 300)); + CHECK(sum == expected_i(100u, 300u)); } { auto sum = immer::accumulate(begin(v) + 31, begin(v) + 300, 0u); - CHECK(sum == expected_i(31, 300)); + CHECK(sum == expected_i(31u, 300u)); } { auto sum = immer::accumulate(begin(v), begin(v) + 33, 0u); - CHECK(sum == expected_i(0, 33)); + CHECK(sum == expected_i(0u, 33u)); } { auto sum = immer::accumulate(begin(v) + 100, begin(v) + 660, 0u); - CHECK(sum == expected_i(100, 660)); + CHECK(sum == expected_i(100u, 660u)); } { auto sum = immer::accumulate(begin(v) + 100, begin(v) + 105, 0u); - CHECK(sum == expected_i(100, 105)); + CHECK(sum == expected_i(100u, 105u)); } { auto sum = immer::accumulate(begin(v) + 660, begin(v) + 664, 0u); - CHECK(sum == expected_i(660, 664)); + CHECK(sum == expected_i(660u, 664u)); } } } @@ -384,6 +404,9 @@ TEST_CASE("vector of strings") struct non_default { unsigned value; + non_default(unsigned value_) + : value{value_} + {} non_default() = delete; operator unsigned() const { return value; } @@ -453,6 +476,22 @@ TEST_CASE("exception safety") IMMER_TRACE_E(d.happenings); } + SECTION("push back move") + { + auto v = dadaist_vector_t{}; + auto d = dadaism{}; + for (auto i = 0u; v.size() < static_cast(n);) { + auto s = d.next(); + try { + v = std::move(v).push_back({i}); + ++i; + } catch (dada_error) {} + CHECK_VECTOR_EQUALS(v, boost::irange(0u, i)); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + SECTION("update") { auto v = make_test_vector(0, n); @@ -470,6 +509,24 @@ TEST_CASE("exception safety") IMMER_TRACE_E(d.happenings); } + SECTION("update move") + { + auto v = make_test_vector(0, n); + auto d = dadaism{}; + for (auto i = 0u; i < n;) { + auto s = d.next(); + try { + v = std::move(v).update(i, + [](auto x) { return dada(), x + 1; }); + ++i; + } catch (dada_error) {} + CHECK_VECTOR_EQUALS( + v, boost::join(boost::irange(1u, 1u + i), boost::irange(i, n))); + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } + SECTION("take") { auto v = make_test_vector(0, n); @@ -487,4 +544,23 @@ TEST_CASE("exception safety") CHECK(d.happenings > 0); IMMER_TRACE_E(d.happenings); } + + SECTION("take move") + { + auto v = make_test_vector(0, n); + auto d = dadaism{}; + auto r = dadaist_vector_t{v}; + for (auto i = 0u; i < n - 1;) { + auto s = d.next(); + try { + r = std::move(r).take(n - i - 1); + CHECK_VECTOR_EQUALS(r, boost::irange(0u, n - i - 1)); + ++i; + } catch (dada_error) { + CHECK_VECTOR_EQUALS(r, boost::irange(0u, n - i)); + } + } + CHECK(d.happenings > 0); + IMMER_TRACE_E(d.happenings); + } } diff --git a/test/vector/issue-177.cpp b/test/vector/issue-177.cpp index 09dff262..ac953d86 100644 --- a/test/vector/issue-177.cpp +++ b/test/vector/issue-177.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include struct object; diff --git a/test/vector/issue-46.cpp b/test/vector/issue-46.cpp index 6475be21..0032b71f 100644 --- a/test/vector/issue-46.cpp +++ b/test/vector/issue-46.cpp @@ -13,7 +13,7 @@ #include #include -#include +#include TEST_CASE("operator==() may return bad result") { diff --git a/test/vector_transient/generic.ipp b/test/vector_transient/generic.ipp index 6cd25a56..6b3e6dad 100644 --- a/test/vector_transient/generic.ipp +++ b/test/vector_transient/generic.ipp @@ -10,7 +10,7 @@ #include "test/transient_tester.hpp" #include "test/util.hpp" -#include +#include #ifndef VECTOR_T #error "define the vector template to use in VECTOR_T" @@ -20,6 +20,8 @@ #error "define the vector template to use in VECTOR_TRANSIENT_T" #endif +IMMER_RANGES_CHECK(std::ranges::random_access_range>); + template > auto make_test_vector(unsigned min, unsigned max) { diff --git a/tools/gdb_pretty_printers/__init__.py b/tools/gdb_pretty_printers/__init__.py new file mode 100644 index 00000000..1bb8bf6d --- /dev/null +++ b/tools/gdb_pretty_printers/__init__.py @@ -0,0 +1 @@ +# empty diff --git a/tools/gdb_pretty_printers/autoload.py b/tools/gdb_pretty_printers/autoload.py new file mode 100644 index 00000000..e3d6d059 --- /dev/null +++ b/tools/gdb_pretty_printers/autoload.py @@ -0,0 +1,14 @@ +import gdb.printing +import os +import sys +import inspect + +filename = inspect.getframeinfo(inspect.currentframe()).filename +path = os.path.dirname(os.path.abspath(filename)) +if not path in sys.path: + sys.path.append(path) +from printers import immer_lookup_function + +gdb.printing.register_pretty_printer(gdb.current_objfile(), immer_lookup_function) + +print("immer gdb pretty-printers loaded") diff --git a/tools/gdb_pretty_printers/printers.py b/tools/gdb_pretty_printers/printers.py new file mode 100644 index 00000000..c33e7efd --- /dev/null +++ b/tools/gdb_pretty_printers/printers.py @@ -0,0 +1,485 @@ +# Sourced from https://gist.github.com/dwightguth/283afe96b60b3793f3c02036701457f8 +# with light modifications. + +import gdb.printing +import decimal +import traceback +import re + +MAX = 1 << 64 - 1 + + +class ArrayIter: + def __init__(self, val): + self.val_ptr = val.type.template_argument(0).pointer() + self.v = val['impl_'] + self.size = self.v['size'] + self.i = 0 + + def __iter__(self): + return self + + def __next__(self): + if self.i == self.size: + raise StopIteration + ptr = self.v['ptr'] + data = ptr.dereference()['impl']['d']['buffer'].address.reinterpret_cast(self.val_ptr) + result = ('[%d]' % self.i, data[self.i]) + self.i += 1 + return result + + +class Relaxed: + def __init__(self, node, shift, relaxed, it): + self.node = node + self.shift = shift + self.relaxed = relaxed + self.it = it + self.B = self.node.type.target().template_argument(2) + self.BL = self.node.type.target().template_argument(3) + + def index(self, idx): + offset = idx >> self.shift + while self.relaxed.dereference()['d']['sizes'][offset] <= idx: + offset += 1 + return offset + + def towards(self, idx): + offset = self.index(idx) + left_size = self.relaxed.dereference()['d']['sizes'][offset - 1] if offset else 0 + child = self.it.inner(self.node)[offset] + is_leaf = self.shift == self.BL + next_size = self.relaxed.dereference()['d']['sizes'][offset] - left_size + next_idx = idx - left_size + if is_leaf: + return self.it.visit_leaf(LeafSub(child, next_size), next_idx) + else: + return self.it.visit_maybe_relaxed_sub(child, self.shift - self.B, next_size, next_idx) + + +class LeafSub: + def __init__(self, node, count): + self.node = node + self.count_ = count + self.BL = self.node.type.target().template_argument(3) + self.MASK = (1 << self.BL) - 1 + + def index(self, idx): + return idx & self.MASK + + def count(self): + return self.count_ + + +class FullLeaf: + def __init__(self, node): + self.node = node + self.BL = self.node.type.target().template_argument(3) + self.BRANCHES = 1 << self.BL + self.MASK = self.BRANCHES - 1 + + def index(self, idx): + return idx & self.MASK + + def count(self): + return self.BRANCHES + + +class Leaf: + def __init__(self, node, size): + self.node = node + self.size = size + self.BL = self.node.type.target().template_argument(3) + self.MASK = (1 << self.BL) - 1 + + def index(self, idx): + return idx & self.MASK + + def count(self): + return self.index(self.size - 1) + 1 + + +class RegularSub: + def __init__(self, node, shift, size, it): + self.node = node + self.shift = shift + self.size = size + self.it = it + self.B = self.node.type.target().template_argument(2) + self.MASK = (1 << self.B) - 1 + + def towards(self, idx): + offset = self.index(idx) + count = self.count() + return self.it.towards_regular(self, idx, offset, count) + + def index(self, idx): + return (idx >> self.shift) & self.MASK + + def count(self): + return self.subindex(self.size - 1) + 1 + + def subindex(self, idx): + return idx >> self.shift + + +class Regular: + def __init__(self, node, shift, size, it): + self.node = node + self.shift = shift + self.size = size + self.it = it + self.B = self.node.type.target().template_argument(2) + self.MASK = (1 << self.B) - 1 + + def index(self, idx): + return (idx >> self.shift) & self.MASK + + def count(self): + return self.index(self.size - 1) + 1 + + def towards(self, idx): + offset = self.index(idx) + count = self.count() + return self.it.towards_regular(self, idx, offset, count) + + +class Full: + def __init__(self, node, shift, it): + self.node = node + self.shift = shift + self.it = it + self.B = self.node.type.target().template_argument(2) + self.BL = self.node.type.target().template_argument(3) + self.MASK = (1 << self.B) - 1 + + def index(self, idx): + return (idx >> self.shift) & self.MASK + + def towards(self, idx): + offset = self.index(idx) + is_leaf = self.shift == self.BL + child = self.it.inner(self.node)[offset] + if is_leaf: + return self.it.visit_leaf(FullLeaf(child), idx) + else: + return Full(child, self.shift - self.B, self.it).towards(idx) + + +class ListIter: + def __init__(self, val): + self.v = val['impl_'] + self.size = self.v['size'] + self.i = 0 + self.curr = (None, MAX, MAX) + self.node_ptr_ptr = self.v['root'].type.pointer() + self.B = self.v['root'].type.target().template_argument(2) + self.BL = self.v['root'].type.target().template_argument(3) + + def __iter__(self): + return self + + def __next__(self): + if self.i == self.size: + raise StopIteration + if self.i < self.curr[1] or self.i >= self.curr[2]: + self.curr = self.region() + result = ('[%d]' % self.i, self.curr[0][self.i - self.curr[1]].cast( + gdb.lookup_type(self.v.type.template_argument(0).name))) + self.i += 1 + return result + + def region(self): + tail_off = self.tail_offset() + if self.i >= tail_off: + return (self.leaf(self.v['tail']), tail_off, self.size) + else: + subs = self.visit_maybe_relaxed_sub(self.v['root'], self.v['shift'], tail_off, self.i) + first = self.i - subs[1] + end = first + subs[2] + return (subs[0], first, end) + + def tail_offset(self): + r = self.relaxed(self.v['root']) + if r: + return r.dereference()['d']['sizes'][r.dereference()['d']['count'] - 1] + elif self.size: + return (self.size - 1) & ~self.leaf_mask() + else: + return 0 + + def relaxed(self, node): + return node.dereference()['impl']['d']['data']['inner']['relaxed'] + + def leaf(self, node): + return node.dereference()['impl']['d']['data']['leaf']['buffer'].address + + def inner(self, node): + return node.dereference()['impl']['d']['data']['inner']['buffer'].address.reinterpret_cast( + self.node_ptr_ptr) + + def visit_maybe_relaxed_sub(self, node, shift, size, idx): + relaxed = self.relaxed(node) + if relaxed: + return Relaxed(node, shift, relaxed, self).towards(idx) + else: + return RegularSub(node, shift, size, self).towards(idx) + + def visit_leaf(self, pos, idx): + return (self.leaf(pos.node), pos.index(idx), pos.count()) + + # pos = node, idx = full, offset = shifted & masked, count = shifted + def towards_regular(self, pos, idx, offset, count): + is_leaf = pos.shift == self.BL + child = self.inner(pos.node)[offset] + is_full = offset + 1 != count + if is_full: + if is_leaf: + return self.visit_leaf(FullLeaf(child), idx) + else: + return Full(child, pos.shift - self.B, self).towards(idx) + elif is_leaf: + return self.visit_leaf(Leaf(child, pos.size), idx) + else: + return Regular(child, pos.shift - self.B, pos.size, self).towards(idx) + + def leaf_mask(self): + return (1 << self.BL) - 1 + + +def popcount(x): + b = 0 + while x > 0: + x &= x - 1 + b += 1 + return b + + +class ChampIter: + def __init__(self, val): + self.depth = 0 + self.count = 0 + v = val['impl_']['root'] + self.node_ptr_ptr = v.type.pointer() + m = self.datamap(v) + if m: + self.cur = self.values(v) + self.end = self.values(v) + popcount(m) + else: + self.cur = None + self.end = None + self.path = [v.address] + self.B = v.type.target().template_argument(4) + self.MAX_DEPTH = ((8 * 8) + self.B - 1) / 8 + self.ensure_valid() + + def __iter__(self): + return self + + def __next__(self): + if self.cur == None: + raise StopIteration + result = self.cur.dereference() + self.cur += 1 + self.count += 1 + self.ensure_valid() + return result + + def ensure_valid(self): + while self.cur == self.end: + while self.step_down(): + if self.cur != self.end: + return + if not self.step_right(): + self.cur = None + self.end = None + return + + def step_down(self): + if self.depth < self.MAX_DEPTH: + parent = self.path[self.depth].dereference() + if self.nodemap(parent): + self.depth += 1 + self.path.append(self.children(parent)) + child = self.path[self.depth] + if self.depth < self.MAX_DEPTH: + m = self.datamap(child) + if m: + self.cur = self.values(child) + self.end = self.cur + popcount(m) + else: + self.cur = self.collisions(child) + self.end = self.cur = self.collision_count(child) + return True + return False + + def step_right(self): + while self.depth > 0: + parent = self.path[self.depth - 1].dereference() + last = self.children(parent) + popcount(self.nodemap(parent)) + next_ = self.path[self.depth] + 1 + if next_ < last: + self.path[self.depth] = next_ + child = self.path[self.depth].dereference() + if self.depth < self.MAX_DEPTH: + m = self.datamap(child) + if m: + self.cur = self.values(child) + self.end = self.cur + popcount(m) + else: + self.cur = self.collisions(child) + self.end = self.cur + self.collision_count(child) + return True + self.depth -= 1 + self.path.pop() + return False + + def values(self, node): + return node.dereference()['impl']['d']['data']['inner']['values'].dereference( + )['d']['buffer'].address.cast(self.T_ptr) + + def children(self, node): + return node.dereference()['impl']['d']['data']['inner']['buffer'].address.cast( + self.node_ptr_ptr) + + def datamap(self, node): + return node.dereference()['impl']['d']['data']['inner']['datamap'] + + def nodemap(self, node): + return node.dereference()['impl']['d']['data']['inner']['nodemap'] + + def collision_count(self, node): + return node.dereference()['impl']['d']['data']['collision']['count'] + + def collisions(self, node): + return node.dereference()['impl']['d']['data']['collision']['buffer'].address.cast( + self.T_ptr) + + +class MapIter(ChampIter): + def __init__(self, val): + self.T_ptr = gdb.lookup_type("std::pair<" + val.type.template_argument(0).name + ", " + + val.type.template_argument(1).name + ">").pointer() + ChampIter.__init__(self, val) + self.pair = None + + def __next__(self): + if self.pair: + result = ('[%d]' % self.count, self.pair['second']) + self.pair = None + return result + self.pair = super().__next__() + return ('[%d]' % self.count, self.pair['first']) + + +class SetIter(ChampIter): + def __init__(self, val): + self.T_ptr = gdb.lookup_type(val.type.template_argument(0).name).pointer() + ChampIter.__init__(self, val) + + def __next__(self): + return ('[%d]' % self.count, super().__next__()) + + +def num_elements(num): + return '1 element' if num == 1 else '%d elements' % num + + +class ArrayPrinter: + "Prints an immer::array" + + def __init__(self, val): + self.val = val + + def to_string(self): + return 'immer::array with %s' % num_elements(self.val['impl_']['size']) + + def children(self): + return ArrayIter(self.val) + + def display_hint(self): + return 'array' + + +class MapPrinter: + "Print an immer::map" + + def __init__(self, val): + self.val = val + + def to_string(self): + return 'immer::map with %s' % num_elements(self.val['impl_']['size']) + + def children(self): + return MapIter(self.val) + + def display_hint(self): + return 'map' + + +class SetPrinter: + "Prints an immer::set" + + def __init__(self, val): + self.val = val + + def to_string(self): + return 'immer::set with %s' % num_elements(self.val['impl_']['size']) + + def children(self): + return SetIter(self.val) + + +class TablePrinter: + "Prints an immer::table" + + def __init__(self, val): + self.val = val + + def to_string(self): + return 'immer::table with %s' % num_elements(self.val['impl_']['size']) + + def children(self): + return SetIter(self.val) + + +class ListPrinter: + "Prints an immer::vector or immer::flex_vector" + + def __init__(self, val, typename): + self.val = val + self.typename = typename + + def to_string(self): + return '%s of length %d' % (self.typename, int(self.val['impl_']['size'])) + + def children(self): + return ListIter(self.val) + + def display_hint(self): + return 'array' + + +def immer_lookup_function(val): + compiled_rx = re.compile('^([a-zA-Z0-9_:]+)(<.*>)?$') + typename = gdb.types.get_basic_type(val.type).tag + if not typename: + return None + match = compiled_rx.match(typename) + if not match: + return None + + basename = match.group(1) + if basename == "immer::array": + return ArrayPrinter(val) + elif basename == "immer::map": + return MapPrinter(val) + elif basename == "immer::set": + return SetPrinter(val) + elif basename == "immer::table": + return TablePrinter(val) + elif basename == "immer::vector": + return ListPrinter(val, "immer::vector") + elif basename == "immer::flex_vector": + return ListPrinter(val, "immer::flex_vector") + return None diff --git a/tools/include/catch.hpp b/tools/include/catch.hpp deleted file mode 100644 index c86bc6ad..00000000 --- a/tools/include/catch.hpp +++ /dev/null @@ -1,9458 +0,0 @@ -/* - * CATCH v1.1 build 3 (master branch) - * Generated: 2015-05-20 13:23:44.423074 - * ---------------------------------------------------------- - * This file has been merged from multiple headers. Please don't edit it directly - * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. - * - * Distributed under the Boost Software License, Version 1.0. (See accompanying - * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - */ -#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED -#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED - -#define TWOBLUECUBES_CATCH_HPP_INCLUDED - -// #included from: internal/catch_suppress_warnings.h - -#define TWOBLUECUBES_CATCH_SUPPRESS_WARNINGS_H_INCLUDED - -#ifdef __clang__ -# ifdef __ICC // icpc defines the __clang__ macro -# pragma warning(push) -# pragma warning(disable: 161 1682) -# else // __ICC -# pragma clang diagnostic ignored "-Wglobal-constructors" -# pragma clang diagnostic ignored "-Wvariadic-macros" -# pragma clang diagnostic ignored "-Wc99-extensions" -# pragma clang diagnostic ignored "-Wunused-variable" -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wpadded" -# pragma clang diagnostic ignored "-Wc++98-compat" -# pragma clang diagnostic ignored "-Wc++98-compat-pedantic" -# endif -#elif defined __GNUC__ -# pragma GCC diagnostic ignored "-Wvariadic-macros" -# pragma GCC diagnostic ignored "-Wunused-variable" -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wpadded" -#endif - -#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) -# define CATCH_IMPL -#endif - -#ifdef CATCH_IMPL -# ifndef CLARA_CONFIG_MAIN -# define CLARA_CONFIG_MAIN_NOT_DEFINED -# define CLARA_CONFIG_MAIN -# endif -#endif - -// #included from: internal/catch_notimplemented_exception.h -#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED - -// #included from: catch_common.h -#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED - -#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line -#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) -#define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) - -#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr -#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) - -#include -#include -#include - -// #included from: catch_compiler_capabilities.h -#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED - -// Detect a number of compiler features - mostly C++11/14 conformance - by compiler -// The following features are defined: -// -// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported? -// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported? -// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods -// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported? -// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported - -// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported? - -// CATCH_CONFIG_SFINAE : is basic (C++03) SFINAE supported? -// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported? - -// A lot of this code is based on Boost (1.53) - -#ifdef __clang__ - -# if __has_feature(cxx_nullptr) -# define CATCH_CONFIG_CPP11_NULLPTR -# endif - -# if __has_feature(cxx_noexcept) -# define CATCH_CONFIG_CPP11_NOEXCEPT -# endif - -#endif // __clang__ - -//////////////////////////////////////////////////////////////////////////////// -// Borland -#ifdef __BORLANDC__ - -#if (__BORLANDC__ > 0x582 ) -//#define CATCH_CONFIG_SFINAE // Not confirmed -#endif - -#endif // __BORLANDC__ - -//////////////////////////////////////////////////////////////////////////////// -// EDG -#ifdef __EDG_VERSION__ - -#if (__EDG_VERSION__ > 238 ) -//#define CATCH_CONFIG_SFINAE // Not confirmed -#endif - -#endif // __EDG_VERSION__ - -//////////////////////////////////////////////////////////////////////////////// -// Digital Mars -#ifdef __DMC__ - -#if (__DMC__ > 0x840 ) -//#define CATCH_CONFIG_SFINAE // Not confirmed -#endif - -#endif // __DMC__ - -//////////////////////////////////////////////////////////////////////////////// -// GCC -#ifdef __GNUC__ - -#if __GNUC__ < 3 - -#if (__GNUC_MINOR__ >= 96 ) -//#define CATCH_CONFIG_SFINAE -#endif - -#elif __GNUC__ >= 3 - -// #define CATCH_CONFIG_SFINAE // Taking this out completely for now - -#endif // __GNUC__ < 3 - -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) ) - -#define CATCH_CONFIG_CPP11_NULLPTR -#endif - -#endif // __GNUC__ - -//////////////////////////////////////////////////////////////////////////////// -// Visual C++ -#ifdef _MSC_VER - -#if (_MSC_VER >= 1310 ) // (VC++ 7.0+) -//#define CATCH_CONFIG_SFINAE // Not confirmed -#endif - -#if (_MSC_VER >= 1600) -#define CATCH_CONFIG_CPP11_NULLPTR -#endif - -#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) -#define CATCH_CONFIG_CPP11_NOEXCEPT -#define CATCH_CONFIG_CPP11_GENERATED_METHODS -#endif - -#endif // _MSC_VER - -// Use variadic macros if the compiler supports them -#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ - ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \ - ( defined __GNUC__ && __GNUC__ >= 3 ) || \ - ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L ) - -#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS -#define CATCH_CONFIG_VARIADIC_MACROS -#endif - -#endif - -//////////////////////////////////////////////////////////////////////////////// -// C++ language feature support - -// catch all support for C++11 -#if (__cplusplus >= 201103L) - -# define CATCH_CPP11_OR_GREATER - -# ifndef CATCH_CONFIG_CPP11_NULLPTR -# define CATCH_CONFIG_CPP11_NULLPTR -# endif - -# ifndef CATCH_CONFIG_CPP11_NOEXCEPT -# define CATCH_CONFIG_CPP11_NOEXCEPT -# endif - -# ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS -# define CATCH_CONFIG_CPP11_GENERATED_METHODS -# endif - -# ifndef CATCH_CONFIG_CPP11_IS_ENUM -# define CATCH_CONFIG_CPP11_IS_ENUM -# endif - -# ifndef CATCH_CONFIG_CPP11_TUPLE -# define CATCH_CONFIG_CPP11_TUPLE -# endif - -# ifndef CATCH_CONFIG_SFINAE -//# define CATCH_CONFIG_SFINAE // Don't use, for now -# endif - -# ifndef CATCH_CONFIG_VARIADIC_MACROS -# define CATCH_CONFIG_VARIADIC_MACROS -# endif - -#endif // __cplusplus >= 201103L - -// noexcept support: -#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT) -# define CATCH_NOEXCEPT noexcept -# define CATCH_NOEXCEPT_IS(x) noexcept(x) -#else -# define CATCH_NOEXCEPT throw() -# define CATCH_NOEXCEPT_IS(x) -#endif - -namespace Catch { - - class NonCopyable { -#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - NonCopyable( NonCopyable const& ) = delete; - NonCopyable( NonCopyable && ) = delete; - NonCopyable& operator = ( NonCopyable const& ) = delete; - NonCopyable& operator = ( NonCopyable && ) = delete; -#else - NonCopyable( NonCopyable const& info ); - NonCopyable& operator = ( NonCopyable const& ); -#endif - - protected: - NonCopyable() {} - virtual ~NonCopyable(); - }; - - class SafeBool { - public: - typedef void (SafeBool::*type)() const; - - static type makeSafe( bool value ) { - return value ? &SafeBool::trueValue : 0; - } - private: - void trueValue() const {} - }; - - template - inline void deleteAll( ContainerT& container ) { - typename ContainerT::const_iterator it = container.begin(); - typename ContainerT::const_iterator itEnd = container.end(); - for(; it != itEnd; ++it ) - delete *it; - } - template - inline void deleteAllValues( AssociativeContainerT& container ) { - typename AssociativeContainerT::const_iterator it = container.begin(); - typename AssociativeContainerT::const_iterator itEnd = container.end(); - for(; it != itEnd; ++it ) - delete it->second; - } - - bool startsWith( std::string const& s, std::string const& prefix ); - bool endsWith( std::string const& s, std::string const& suffix ); - bool contains( std::string const& s, std::string const& infix ); - void toLowerInPlace( std::string& s ); - std::string toLower( std::string const& s ); - std::string trim( std::string const& str ); - bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ); - - struct pluralise { - pluralise( std::size_t count, std::string const& label ); - - friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); - - std::size_t m_count; - std::string m_label; - }; - - struct SourceLineInfo { - - SourceLineInfo(); - SourceLineInfo( char const* _file, std::size_t _line ); - SourceLineInfo( SourceLineInfo const& other ); -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - SourceLineInfo( SourceLineInfo && ) = default; - SourceLineInfo& operator = ( SourceLineInfo const& ) = default; - SourceLineInfo& operator = ( SourceLineInfo && ) = default; -# endif - bool empty() const; - bool operator == ( SourceLineInfo const& other ) const; - bool operator < ( SourceLineInfo const& other ) const; - - std::string file; - std::size_t line; - }; - - std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); - - // This is just here to avoid compiler warnings with macro constants and boolean literals - inline bool isTrue( bool value ){ return value; } - inline bool alwaysTrue() { return true; } - inline bool alwaysFalse() { return false; } - - void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); - - // Use this in variadic streaming macros to allow - // >> +StreamEndStop - // as well as - // >> stuff +StreamEndStop - struct StreamEndStop { - std::string operator+() { - return std::string(); - } - }; - template - T const& operator + ( T const& value, StreamEndStop ) { - return value; - } -} - -#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) -#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); - -#include - -namespace Catch { - - class NotImplementedException : public std::exception - { - public: - NotImplementedException( SourceLineInfo const& lineInfo ); - NotImplementedException( NotImplementedException const& ) {} - - virtual ~NotImplementedException() CATCH_NOEXCEPT {} - - virtual const char* what() const CATCH_NOEXCEPT; - - private: - std::string m_what; - SourceLineInfo m_lineInfo; - }; - -} // end namespace Catch - -/////////////////////////////////////////////////////////////////////////////// -#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO ) - -// #included from: internal/catch_context.h -#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED - -// #included from: catch_interfaces_generators.h -#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED - -#include - -namespace Catch { - - struct IGeneratorInfo { - virtual ~IGeneratorInfo(); - virtual bool moveNext() = 0; - virtual std::size_t getCurrentIndex() const = 0; - }; - - struct IGeneratorsForTest { - virtual ~IGeneratorsForTest(); - - virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; - virtual bool moveNext() = 0; - }; - - IGeneratorsForTest* createGeneratorsForTest(); - -} // end namespace Catch - -// #included from: catch_ptr.hpp -#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wpadded" -#endif - -namespace Catch { - - // An intrusive reference counting smart pointer. - // T must implement addRef() and release() methods - // typically implementing the IShared interface - template - class Ptr { - public: - Ptr() : m_p( NULL ){} - Ptr( T* p ) : m_p( p ){ - if( m_p ) - m_p->addRef(); - } - Ptr( Ptr const& other ) : m_p( other.m_p ){ - if( m_p ) - m_p->addRef(); - } - ~Ptr(){ - if( m_p ) - m_p->release(); - } - void reset() { - if( m_p ) - m_p->release(); - m_p = NULL; - } - Ptr& operator = ( T* p ){ - Ptr temp( p ); - swap( temp ); - return *this; - } - Ptr& operator = ( Ptr const& other ){ - Ptr temp( other ); - swap( temp ); - return *this; - } - void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } - T* get() { return m_p; } - const T* get() const{ return m_p; } - T& operator*() const { return *m_p; } - T* operator->() const { return m_p; } - bool operator !() const { return m_p == NULL; } - operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); } - - private: - T* m_p; - }; - - struct IShared : NonCopyable { - virtual ~IShared(); - virtual void addRef() const = 0; - virtual void release() const = 0; - }; - - template - struct SharedImpl : T { - - SharedImpl() : m_rc( 0 ){} - - virtual void addRef() const { - ++m_rc; - } - virtual void release() const { - if( --m_rc == 0 ) - delete this; - } - - mutable unsigned int m_rc; - }; - -} // end namespace Catch - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -#include -#include -#include - -namespace Catch { - - class TestCase; - class Stream; - struct IResultCapture; - struct IRunner; - struct IGeneratorsForTest; - struct IConfig; - - struct IContext - { - virtual ~IContext(); - - virtual IResultCapture* getResultCapture() = 0; - virtual IRunner* getRunner() = 0; - virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; - virtual bool advanceGeneratorsForCurrentTest() = 0; - virtual Ptr getConfig() const = 0; - }; - - struct IMutableContext : IContext - { - virtual ~IMutableContext(); - virtual void setResultCapture( IResultCapture* resultCapture ) = 0; - virtual void setRunner( IRunner* runner ) = 0; - virtual void setConfig( Ptr const& config ) = 0; - }; - - IContext& getCurrentContext(); - IMutableContext& getCurrentMutableContext(); - void cleanUpContext(); - Stream createStream( std::string const& streamName ); - -} - -// #included from: internal/catch_test_registry.hpp -#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED - -// #included from: catch_interfaces_testcase.h -#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED - -#include - -namespace Catch { - - class TestSpec; - - struct ITestCase : IShared { - virtual void invoke () const = 0; - protected: - virtual ~ITestCase(); - }; - - class TestCase; - struct IConfig; - - struct ITestCaseRegistry { - virtual ~ITestCaseRegistry(); - virtual std::vector const& getAllTests() const = 0; - virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector& matchingTestCases, bool negated = false ) const = 0; - - }; -} - -namespace Catch { - -template -class MethodTestCase : public SharedImpl { - -public: - MethodTestCase( void (C::*method)() ) : m_method( method ) {} - - virtual void invoke() const { - C obj; - (obj.*m_method)(); - } - -private: - virtual ~MethodTestCase() {} - - void (C::*m_method)(); -}; - -typedef void(*TestFunction)(); - -struct NameAndDesc { - NameAndDesc( const char* _name = "", const char* _description= "" ) - : name( _name ), description( _description ) - {} - - const char* name; - const char* description; -}; - -struct AutoReg { - - AutoReg( TestFunction function, - SourceLineInfo const& lineInfo, - NameAndDesc const& nameAndDesc ); - - template - AutoReg( void (C::*method)(), - char const* className, - NameAndDesc const& nameAndDesc, - SourceLineInfo const& lineInfo ) { - registerTestCase( new MethodTestCase( method ), - className, - nameAndDesc, - lineInfo ); - } - - void registerTestCase( ITestCase* testCase, - char const* className, - NameAndDesc const& nameAndDesc, - SourceLineInfo const& lineInfo ); - - ~AutoReg(); - -private: - AutoReg( AutoReg const& ); - void operator= ( AutoReg const& ); -}; - -} // end namespace Catch - -#ifdef CATCH_CONFIG_VARIADIC_MACROS - /////////////////////////////////////////////////////////////////////////////// - #define INTERNAL_CATCH_TESTCASE( ... ) \ - static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \ - namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\ - static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )() - - /////////////////////////////////////////////////////////////////////////////// - #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \ - namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } - - /////////////////////////////////////////////////////////////////////////////// - #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\ - namespace{ \ - struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \ - void test(); \ - }; \ - Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \ - } \ - void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test() - -#else - /////////////////////////////////////////////////////////////////////////////// - #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \ - static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \ - namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\ - static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )() - - /////////////////////////////////////////////////////////////////////////////// - #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \ - namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } - - /////////////////////////////////////////////////////////////////////////////// - #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\ - namespace{ \ - struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \ - void test(); \ - }; \ - Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \ - } \ - void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test() - -#endif - -// #included from: internal/catch_capture.hpp -#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED - -// #included from: catch_result_builder.h -#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED - -// #included from: catch_result_type.h -#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED - -namespace Catch { - - // ResultWas::OfType enum - struct ResultWas { enum OfType { - Unknown = -1, - Ok = 0, - Info = 1, - Warning = 2, - - FailureBit = 0x10, - - ExpressionFailed = FailureBit | 1, - ExplicitFailure = FailureBit | 2, - - Exception = 0x100 | FailureBit, - - ThrewException = Exception | 1, - DidntThrowException = Exception | 2, - - FatalErrorCondition = 0x200 | FailureBit - - }; }; - - inline bool isOk( ResultWas::OfType resultType ) { - return ( resultType & ResultWas::FailureBit ) == 0; - } - inline bool isJustInfo( int flags ) { - return flags == ResultWas::Info; - } - - // ResultDisposition::Flags enum - struct ResultDisposition { enum Flags { - Normal = 0x01, - - ContinueOnFailure = 0x02, // Failures fail test, but execution continues - FalseTest = 0x04, // Prefix expression with ! - SuppressFail = 0x08 // Failures are reported but do not fail the test - }; }; - - inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) { - return static_cast( static_cast( lhs ) | static_cast( rhs ) ); - } - - inline bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; } - inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; } - inline bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; } - -} // end namespace Catch - -// #included from: catch_assertionresult.h -#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED - -#include - -namespace Catch { - - struct AssertionInfo - { - AssertionInfo() {} - AssertionInfo( std::string const& _macroName, - SourceLineInfo const& _lineInfo, - std::string const& _capturedExpression, - ResultDisposition::Flags _resultDisposition ); - - std::string macroName; - SourceLineInfo lineInfo; - std::string capturedExpression; - ResultDisposition::Flags resultDisposition; - }; - - struct AssertionResultData - { - AssertionResultData() : resultType( ResultWas::Unknown ) {} - - std::string reconstructedExpression; - std::string message; - ResultWas::OfType resultType; - }; - - class AssertionResult { - public: - AssertionResult(); - AssertionResult( AssertionInfo const& info, AssertionResultData const& data ); - ~AssertionResult(); -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - AssertionResult( AssertionResult const& ) = default; - AssertionResult( AssertionResult && ) = default; - AssertionResult& operator = ( AssertionResult const& ) = default; - AssertionResult& operator = ( AssertionResult && ) = default; -# endif - - bool isOk() const; - bool succeeded() const; - ResultWas::OfType getResultType() const; - bool hasExpression() const; - bool hasMessage() const; - std::string getExpression() const; - std::string getExpressionInMacro() const; - bool hasExpandedExpression() const; - std::string getExpandedExpression() const; - std::string getMessage() const; - SourceLineInfo getSourceInfo() const; - std::string getTestMacroName() const; - - protected: - AssertionInfo m_info; - AssertionResultData m_resultData; - }; - -} // end namespace Catch - -namespace Catch { - - struct TestFailureException{}; - - template class ExpressionLhs; - - struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; - - struct CopyableStream { - CopyableStream() {} - CopyableStream( CopyableStream const& other ) { - oss << other.oss.str(); - } - CopyableStream& operator=( CopyableStream const& other ) { - oss.str(""); - oss << other.oss.str(); - return *this; - } - std::ostringstream oss; - }; - - class ResultBuilder { - public: - ResultBuilder( char const* macroName, - SourceLineInfo const& lineInfo, - char const* capturedExpression, - ResultDisposition::Flags resultDisposition ); - - template - ExpressionLhs operator->* ( T const& operand ); - ExpressionLhs operator->* ( bool value ); - - template - ResultBuilder& operator << ( T const& value ) { - m_stream.oss << value; - return *this; - } - - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); - - ResultBuilder& setResultType( ResultWas::OfType result ); - ResultBuilder& setResultType( bool result ); - ResultBuilder& setLhs( std::string const& lhs ); - ResultBuilder& setRhs( std::string const& rhs ); - ResultBuilder& setOp( std::string const& op ); - - void endExpression(); - - std::string reconstructExpression() const; - AssertionResult build() const; - - void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal ); - void captureResult( ResultWas::OfType resultType ); - void captureExpression(); - void react(); - bool shouldDebugBreak() const; - bool allowThrows() const; - - private: - AssertionInfo m_assertionInfo; - AssertionResultData m_data; - struct ExprComponents { - ExprComponents() : testFalse( false ) {} - bool testFalse; - std::string lhs, rhs, op; - } m_exprComponents; - CopyableStream m_stream; - - bool m_shouldDebugBreak; - bool m_shouldThrow; - }; - -} // namespace Catch - -// Include after due to circular dependency: -// #included from: catch_expression_lhs.hpp -#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED - -// #included from: catch_evaluate.hpp -#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable:4389) // '==' : signed/unsigned mismatch -#endif - -#include - -namespace Catch { -namespace Internal { - - enum Operator { - IsEqualTo, - IsNotEqualTo, - IsLessThan, - IsGreaterThan, - IsLessThanOrEqualTo, - IsGreaterThanOrEqualTo - }; - - template struct OperatorTraits { static const char* getName(){ return "*error*"; } }; - template<> struct OperatorTraits { static const char* getName(){ return "=="; } }; - template<> struct OperatorTraits { static const char* getName(){ return "!="; } }; - template<> struct OperatorTraits { static const char* getName(){ return "<"; } }; - template<> struct OperatorTraits { static const char* getName(){ return ">"; } }; - template<> struct OperatorTraits { static const char* getName(){ return "<="; } }; - template<> struct OperatorTraits{ static const char* getName(){ return ">="; } }; - - template - inline T& opCast(T const& t) { return const_cast(t); } - -// nullptr_t support based on pull request #154 from Konstantin Baumann -#ifdef CATCH_CONFIG_CPP11_NULLPTR - inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; } -#endif // CATCH_CONFIG_CPP11_NULLPTR - - // So the compare overloads can be operator agnostic we convey the operator as a template - // enum, which is used to specialise an Evaluator for doing the comparison. - template - class Evaluator{}; - - template - struct Evaluator { - static bool evaluate( T1 const& lhs, T2 const& rhs) { - return opCast( lhs ) == opCast( rhs ); - } - }; - template - struct Evaluator { - static bool evaluate( T1 const& lhs, T2 const& rhs ) { - return opCast( lhs ) != opCast( rhs ); - } - }; - template - struct Evaluator { - static bool evaluate( T1 const& lhs, T2 const& rhs ) { - return opCast( lhs ) < opCast( rhs ); - } - }; - template - struct Evaluator { - static bool evaluate( T1 const& lhs, T2 const& rhs ) { - return opCast( lhs ) > opCast( rhs ); - } - }; - template - struct Evaluator { - static bool evaluate( T1 const& lhs, T2 const& rhs ) { - return opCast( lhs ) >= opCast( rhs ); - } - }; - template - struct Evaluator { - static bool evaluate( T1 const& lhs, T2 const& rhs ) { - return opCast( lhs ) <= opCast( rhs ); - } - }; - - template - bool applyEvaluator( T1 const& lhs, T2 const& rhs ) { - return Evaluator::evaluate( lhs, rhs ); - } - - // This level of indirection allows us to specialise for integer types - // to avoid signed/ unsigned warnings - - // "base" overload - template - bool compare( T1 const& lhs, T2 const& rhs ) { - return Evaluator::evaluate( lhs, rhs ); - } - - // unsigned X to int - template bool compare( unsigned int lhs, int rhs ) { - return applyEvaluator( lhs, static_cast( rhs ) ); - } - template bool compare( unsigned long lhs, int rhs ) { - return applyEvaluator( lhs, static_cast( rhs ) ); - } - template bool compare( unsigned char lhs, int rhs ) { - return applyEvaluator( lhs, static_cast( rhs ) ); - } - - // unsigned X to long - template bool compare( unsigned int lhs, long rhs ) { - return applyEvaluator( lhs, static_cast( rhs ) ); - } - template bool compare( unsigned long lhs, long rhs ) { - return applyEvaluator( lhs, static_cast( rhs ) ); - } - template bool compare( unsigned char lhs, long rhs ) { - return applyEvaluator( lhs, static_cast( rhs ) ); - } - - // int to unsigned X - template bool compare( int lhs, unsigned int rhs ) { - return applyEvaluator( static_cast( lhs ), rhs ); - } - template bool compare( int lhs, unsigned long rhs ) { - return applyEvaluator( static_cast( lhs ), rhs ); - } - template bool compare( int lhs, unsigned char rhs ) { - return applyEvaluator( static_cast( lhs ), rhs ); - } - - // long to unsigned X - template bool compare( long lhs, unsigned int rhs ) { - return applyEvaluator( static_cast( lhs ), rhs ); - } - template bool compare( long lhs, unsigned long rhs ) { - return applyEvaluator( static_cast( lhs ), rhs ); - } - template bool compare( long lhs, unsigned char rhs ) { - return applyEvaluator( static_cast( lhs ), rhs ); - } - - // pointer to long (when comparing against NULL) - template bool compare( long lhs, T* rhs ) { - return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); - } - template bool compare( T* lhs, long rhs ) { - return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); - } - - // pointer to int (when comparing against NULL) - template bool compare( int lhs, T* rhs ) { - return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); - } - template bool compare( T* lhs, int rhs ) { - return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); - } - -#ifdef CATCH_CONFIG_CPP11_NULLPTR - // pointer to nullptr_t (when comparing against nullptr) - template bool compare( std::nullptr_t, T* rhs ) { - return Evaluator::evaluate( NULL, rhs ); - } - template bool compare( T* lhs, std::nullptr_t ) { - return Evaluator::evaluate( lhs, NULL ); - } -#endif // CATCH_CONFIG_CPP11_NULLPTR - -} // end of namespace Internal -} // end of namespace Catch - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -// #included from: catch_tostring.h -#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED - -// #included from: catch_sfinae.hpp -#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED - -// Try to detect if the current compiler supports SFINAE - -namespace Catch { - - struct TrueType { - static const bool value = true; - typedef void Enable; - char sizer[1]; - }; - struct FalseType { - static const bool value = false; - typedef void Disable; - char sizer[2]; - }; - -#ifdef CATCH_CONFIG_SFINAE - - template struct NotABooleanExpression; - - template struct If : NotABooleanExpression {}; - template<> struct If : TrueType {}; - template<> struct If : FalseType {}; - - template struct SizedIf; - template<> struct SizedIf : TrueType {}; - template<> struct SizedIf : FalseType {}; - -#endif // CATCH_CONFIG_SFINAE - -} // end namespace Catch - -#include -#include -#include -#include -#include - -#ifdef __OBJC__ -// #included from: catch_objc_arc.hpp -#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED - -#import - -#ifdef __has_feature -#define CATCH_ARC_ENABLED __has_feature(objc_arc) -#else -#define CATCH_ARC_ENABLED 0 -#endif - -void arcSafeRelease( NSObject* obj ); -id performOptionalSelector( id obj, SEL sel ); - -#if !CATCH_ARC_ENABLED -inline void arcSafeRelease( NSObject* obj ) { - [obj release]; -} -inline id performOptionalSelector( id obj, SEL sel ) { - if( [obj respondsToSelector: sel] ) - return [obj performSelector: sel]; - return nil; -} -#define CATCH_UNSAFE_UNRETAINED -#define CATCH_ARC_STRONG -#else -inline void arcSafeRelease( NSObject* ){} -inline id performOptionalSelector( id obj, SEL sel ) { -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Warc-performSelector-leaks" -#endif - if( [obj respondsToSelector: sel] ) - return [obj performSelector: sel]; -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - return nil; -} -#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained -#define CATCH_ARC_STRONG __strong -#endif - -#endif - -#ifdef CATCH_CONFIG_CPP11_TUPLE -#include -#endif - -#ifdef CATCH_CONFIG_CPP11_IS_ENUM -#include -#endif - -namespace Catch { - -// Why we're here. -template -std::string toString( T const& value ); - -// Built in overloads - -std::string toString( std::string const& value ); -std::string toString( std::wstring const& value ); -std::string toString( const char* const value ); -std::string toString( char* const value ); -std::string toString( const wchar_t* const value ); -std::string toString( wchar_t* const value ); -std::string toString( int value ); -std::string toString( unsigned long value ); -std::string toString( unsigned int value ); -std::string toString( const double value ); -std::string toString( const float value ); -std::string toString( bool value ); -std::string toString( char value ); -std::string toString( signed char value ); -std::string toString( unsigned char value ); - -#ifdef CATCH_CONFIG_CPP11_NULLPTR -std::string toString( std::nullptr_t ); -#endif - -#ifdef __OBJC__ - std::string toString( NSString const * const& nsstring ); - std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ); - std::string toString( NSObject* const& nsObject ); -#endif - -namespace Detail { - - extern std::string unprintableString; - -// SFINAE is currently disabled by default for all compilers. -// If the non SFINAE version of IsStreamInsertable is ambiguous for you -// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE -#ifdef CATCH_CONFIG_SFINAE - - template - class IsStreamInsertableHelper { - template struct TrueIfSizeable : TrueType {}; - - template - static TrueIfSizeable dummy(T2*); - static FalseType dummy(...); - - public: - typedef SizedIf type; - }; - - template - struct IsStreamInsertable : IsStreamInsertableHelper::type {}; - -#else - - struct BorgType { - template BorgType( T const& ); - }; - - TrueType& testStreamable( std::ostream& ); - FalseType testStreamable( FalseType ); - - FalseType operator<<( std::ostream const&, BorgType const& ); - - template - struct IsStreamInsertable { - static std::ostream &s; - static T const&t; - enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) }; - }; - -#endif - -#if defined(CATCH_CONFIG_CPP11_IS_ENUM) - template::value - > - struct EnumStringMaker - { - static std::string convert( T const& ) { return unprintableString; } - }; - - template - struct EnumStringMaker - { - static std::string convert( T const& v ) - { - return ::Catch::toString( - static_cast::type>(v) - ); - } - }; -#endif - template - struct StringMakerBase { -#if defined(CATCH_CONFIG_CPP11_IS_ENUM) - template - static std::string convert( T const& v ) - { - return EnumStringMaker::convert( v ); - } -#else - template - static std::string convert( T const& ) { return unprintableString; } -#endif - }; - - template<> - struct StringMakerBase { - template - static std::string convert( T const& _value ) { - std::ostringstream oss; - oss << _value; - return oss.str(); - } - }; - - std::string rawMemoryToString( const void *object, std::size_t size ); - - template - inline std::string rawMemoryToString( const T& object ) { - return rawMemoryToString( &object, sizeof(object) ); - } - -} // end namespace Detail - -template -struct StringMaker : - Detail::StringMakerBase::value> {}; - -template -struct StringMaker { - template - static std::string convert( U* p ) { - if( !p ) - return INTERNAL_CATCH_STRINGIFY( NULL ); - else - return Detail::rawMemoryToString( p ); - } -}; - -template -struct StringMaker { - static std::string convert( R C::* p ) { - if( !p ) - return INTERNAL_CATCH_STRINGIFY( NULL ); - else - return Detail::rawMemoryToString( p ); - } -}; - -namespace Detail { - template - std::string rangeToString( InputIterator first, InputIterator last ); -} - -//template -//struct StringMaker > { -// static std::string convert( std::vector const& v ) { -// return Detail::rangeToString( v.begin(), v.end() ); -// } -//}; - -template -std::string toString( std::vector const& v ) { - return Detail::rangeToString( v.begin(), v.end() ); -} - -#ifdef CATCH_CONFIG_CPP11_TUPLE - -// toString for tuples -namespace TupleDetail { - template< - typename Tuple, - std::size_t N = 0, - bool = (N < std::tuple_size::value) - > - struct ElementPrinter { - static void print( const Tuple& tuple, std::ostream& os ) - { - os << ( N ? ", " : " " ) - << Catch::toString(std::get(tuple)); - ElementPrinter::print(tuple,os); - } - }; - - template< - typename Tuple, - std::size_t N - > - struct ElementPrinter { - static void print( const Tuple&, std::ostream& ) {} - }; - -} - -template -struct StringMaker> { - - static std::string convert( const std::tuple& tuple ) - { - std::ostringstream os; - os << '{'; - TupleDetail::ElementPrinter>::print( tuple, os ); - os << " }"; - return os.str(); - } -}; -#endif // CATCH_CONFIG_CPP11_TUPLE - -namespace Detail { - template - std::string makeString( T const& value ) { - return StringMaker::convert( value ); - } -} // end namespace Detail - -/// \brief converts any type to a string -/// -/// The default template forwards on to ostringstream - except when an -/// ostringstream overload does not exist - in which case it attempts to detect -/// that and writes {?}. -/// Overload (not specialise) this template for custom typs that you don't want -/// to provide an ostream overload for. -template -std::string toString( T const& value ) { - return StringMaker::convert( value ); -} - - namespace Detail { - template - std::string rangeToString( InputIterator first, InputIterator last ) { - std::ostringstream oss; - oss << "{ "; - if( first != last ) { - oss << Catch::toString( *first ); - for( ++first ; first != last ; ++first ) - oss << ", " << Catch::toString( *first ); - } - oss << " }"; - return oss.str(); - } -} - -} // end namespace Catch - -namespace Catch { - -// Wraps the LHS of an expression and captures the operator and RHS (if any) - -// wrapping them all in a ResultBuilder object -template -class ExpressionLhs { - ExpressionLhs& operator = ( ExpressionLhs const& ); -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - ExpressionLhs& operator = ( ExpressionLhs && ) = delete; -# endif - -public: - ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {} -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - ExpressionLhs( ExpressionLhs const& ) = default; - ExpressionLhs( ExpressionLhs && ) = default; -# endif - - template - ResultBuilder& operator == ( RhsT const& rhs ) { - return captureExpression( rhs ); - } - - template - ResultBuilder& operator != ( RhsT const& rhs ) { - return captureExpression( rhs ); - } - - template - ResultBuilder& operator < ( RhsT const& rhs ) { - return captureExpression( rhs ); - } - - template - ResultBuilder& operator > ( RhsT const& rhs ) { - return captureExpression( rhs ); - } - - template - ResultBuilder& operator <= ( RhsT const& rhs ) { - return captureExpression( rhs ); - } - - template - ResultBuilder& operator >= ( RhsT const& rhs ) { - return captureExpression( rhs ); - } - - ResultBuilder& operator == ( bool rhs ) { - return captureExpression( rhs ); - } - - ResultBuilder& operator != ( bool rhs ) { - return captureExpression( rhs ); - } - - void endExpression() { - bool value = m_lhs ? true : false; - m_rb - .setLhs( Catch::toString( value ) ) - .setResultType( value ) - .endExpression(); - } - - // Only simple binary expressions are allowed on the LHS. - // If more complex compositions are required then place the sub expression in parentheses - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& ); - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& ); - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& ); - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& ); - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); - template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); - -private: - template - ResultBuilder& captureExpression( RhsT const& rhs ) { - return m_rb - .setResultType( Internal::compare( m_lhs, rhs ) ) - .setLhs( Catch::toString( m_lhs ) ) - .setRhs( Catch::toString( rhs ) ) - .setOp( Internal::OperatorTraits::getName() ); - } - -private: - ResultBuilder& m_rb; - T m_lhs; -}; - -} // end namespace Catch - - -namespace Catch { - - template - inline ExpressionLhs ResultBuilder::operator->* ( T const& operand ) { - return ExpressionLhs( *this, operand ); - } - - inline ExpressionLhs ResultBuilder::operator->* ( bool value ) { - return ExpressionLhs( *this, value ); - } - -} // namespace Catch - -// #included from: catch_message.h -#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED - -#include - -namespace Catch { - - struct MessageInfo { - MessageInfo( std::string const& _macroName, - SourceLineInfo const& _lineInfo, - ResultWas::OfType _type ); - - std::string macroName; - SourceLineInfo lineInfo; - ResultWas::OfType type; - std::string message; - unsigned int sequence; - - bool operator == ( MessageInfo const& other ) const { - return sequence == other.sequence; - } - bool operator < ( MessageInfo const& other ) const { - return sequence < other.sequence; - } - private: - static unsigned int globalCount; - }; - - struct MessageBuilder { - MessageBuilder( std::string const& macroName, - SourceLineInfo const& lineInfo, - ResultWas::OfType type ) - : m_info( macroName, lineInfo, type ) - {} - - template - MessageBuilder& operator << ( T const& value ) { - m_stream << value; - return *this; - } - - MessageInfo m_info; - std::ostringstream m_stream; - }; - - class ScopedMessage { - public: - ScopedMessage( MessageBuilder const& builder ); - ScopedMessage( ScopedMessage const& other ); - ~ScopedMessage(); - - MessageInfo m_info; - }; - -} // end namespace Catch - -// #included from: catch_interfaces_capture.h -#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED - -#include - -namespace Catch { - - class TestCase; - class AssertionResult; - struct AssertionInfo; - struct SectionInfo; - struct MessageInfo; - class ScopedMessageBuilder; - struct Counts; - - struct IResultCapture { - - virtual ~IResultCapture(); - - virtual void assertionEnded( AssertionResult const& result ) = 0; - virtual bool sectionStarted( SectionInfo const& sectionInfo, - Counts& assertions ) = 0; - virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0; - virtual void pushScopedMessage( MessageInfo const& message ) = 0; - virtual void popScopedMessage( MessageInfo const& message ) = 0; - - virtual std::string getCurrentTestName() const = 0; - virtual const AssertionResult* getLastResult() const = 0; - - virtual void handleFatalErrorCondition( std::string const& message ) = 0; - }; - - IResultCapture& getResultCapture(); -} - -// #included from: catch_debugger.h -#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED - -// #included from: catch_platform.h -#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED - -#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) -#define CATCH_PLATFORM_MAC -#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) -#define CATCH_PLATFORM_IPHONE -#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) -#define CATCH_PLATFORM_WINDOWS -#endif - -#include -#include - -namespace Catch{ - - bool isDebuggerActive(); - void writeToDebugConsole( std::string const& text ); -} - -#ifdef CATCH_PLATFORM_MAC - - // The following code snippet based on: - // http://cocoawithlove.com/2008/03/break-into-debugger.html - #ifdef DEBUG - #if defined(__ppc64__) || defined(__ppc__) - #define CATCH_BREAK_INTO_DEBUGGER() \ - if( Catch::isDebuggerActive() ) { \ - __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \ - : : : "memory","r0","r3","r4" ); \ - } - #else - #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );} - #endif - #endif - -#elif defined(_MSC_VER) - #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); } -#elif defined(__MINGW32__) - extern "C" __declspec(dllimport) void __stdcall DebugBreak(); - #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); } -#else - #define CATCH_BREAK_INTO_DEBUGGER() raise(SIGTRAP); -#endif - -#ifndef CATCH_BREAK_INTO_DEBUGGER -#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue(); -#endif - -// #included from: catch_interfaces_runner.h -#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED - -namespace Catch { - class TestCase; - - struct IRunner { - virtual ~IRunner(); - virtual bool aborting() const = 0; - }; -} - -/////////////////////////////////////////////////////////////////////////////// -// In the event of a failure works out if the debugger needs to be invoked -// and/or an exception thrown and takes appropriate action. -// This needs to be done as a macro so the debugger will stop in the user -// source code rather than in Catch library code -#define INTERNAL_CATCH_REACT( resultBuilder ) \ - if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \ - resultBuilder.react(); - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ - try { \ - ( __catchResult->*expr ).endExpression(); \ - } \ - catch( ... ) { \ - __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \ - } \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::isTrue( false && (expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \ - INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ - if( Catch::getResultCapture().getLastResult()->succeeded() ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \ - INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ - if( !Catch::getResultCapture().getLastResult()->succeeded() ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ - try { \ - expr; \ - __catchResult.captureResult( Catch::ResultWas::Ok ); \ - } \ - catch( ... ) { \ - __catchResult.useActiveException( resultDisposition ); \ - } \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::alwaysFalse() ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_THROWS( expr, resultDisposition, macroName ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ - if( __catchResult.allowThrows() ) \ - try { \ - expr; \ - __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ - } \ - catch( ... ) { \ - __catchResult.captureResult( Catch::ResultWas::Ok ); \ - } \ - else \ - __catchResult.captureResult( Catch::ResultWas::Ok ); \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::alwaysFalse() ) - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ - if( __catchResult.allowThrows() ) \ - try { \ - expr; \ - __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ - } \ - catch( exceptionType ) { \ - __catchResult.captureResult( Catch::ResultWas::Ok ); \ - } \ - catch( ... ) { \ - __catchResult.useActiveException( resultDisposition ); \ - } \ - else \ - __catchResult.captureResult( Catch::ResultWas::Ok ); \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::alwaysFalse() ) - -/////////////////////////////////////////////////////////////////////////////// -#ifdef CATCH_CONFIG_VARIADIC_MACROS - #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ - __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \ - __catchResult.captureResult( messageType ); \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::alwaysFalse() ) -#else - #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ - __catchResult << log + ::Catch::StreamEndStop(); \ - __catchResult.captureResult( messageType ); \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::alwaysFalse() ) -#endif - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_INFO( log, macroName ) \ - Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log; - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \ - do { \ - Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher, resultDisposition ); \ - try { \ - std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \ - __catchResult \ - .setLhs( Catch::toString( arg ) ) \ - .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \ - .setOp( "matches" ) \ - .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \ - __catchResult.captureExpression(); \ - } catch( ... ) { \ - __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \ - } \ - INTERNAL_CATCH_REACT( __catchResult ) \ - } while( Catch::alwaysFalse() ) - -// #included from: internal/catch_section.h -#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED - -// #included from: catch_section_info.h -#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED - -namespace Catch { - - struct SectionInfo { - SectionInfo - ( SourceLineInfo const& _lineInfo, - std::string const& _name, - std::string const& _description = std::string() ); - - std::string name; - std::string description; - SourceLineInfo lineInfo; - }; - -} // end namespace Catch - -// #included from: catch_totals.hpp -#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED - -#include - -namespace Catch { - - struct Counts { - Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {} - - Counts operator - ( Counts const& other ) const { - Counts diff; - diff.passed = passed - other.passed; - diff.failed = failed - other.failed; - diff.failedButOk = failedButOk - other.failedButOk; - return diff; - } - Counts& operator += ( Counts const& other ) { - passed += other.passed; - failed += other.failed; - failedButOk += other.failedButOk; - return *this; - } - - std::size_t total() const { - return passed + failed + failedButOk; - } - bool allPassed() const { - return failed == 0 && failedButOk == 0; - } - bool allOk() const { - return failed == 0; - } - - std::size_t passed; - std::size_t failed; - std::size_t failedButOk; - }; - - struct Totals { - - Totals operator - ( Totals const& other ) const { - Totals diff; - diff.assertions = assertions - other.assertions; - diff.testCases = testCases - other.testCases; - return diff; - } - - Totals delta( Totals const& prevTotals ) const { - Totals diff = *this - prevTotals; - if( diff.assertions.failed > 0 ) - ++diff.testCases.failed; - else if( diff.assertions.failedButOk > 0 ) - ++diff.testCases.failedButOk; - else - ++diff.testCases.passed; - return diff; - } - - Totals& operator += ( Totals const& other ) { - assertions += other.assertions; - testCases += other.testCases; - return *this; - } - - Counts assertions; - Counts testCases; - }; -} - -// #included from: catch_timer.h -#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED - -#ifdef CATCH_PLATFORM_WINDOWS -typedef unsigned long long uint64_t; -#else -#include -#endif - -namespace Catch { - - class Timer { - public: - Timer() : m_ticks( 0 ) {} - void start(); - unsigned int getElapsedMicroseconds() const; - unsigned int getElapsedMilliseconds() const; - double getElapsedSeconds() const; - - private: - uint64_t m_ticks; - }; - -} // namespace Catch - -#include - -namespace Catch { - - class Section : NonCopyable { - public: - Section( SectionInfo const& info ); - ~Section(); - - // This indicates whether the section should be executed or not - operator bool() const; - - private: - SectionInfo m_info; - - std::string m_name; - Counts m_assertions; - bool m_sectionIncluded; - Timer m_timer; - }; - -} // end namespace Catch - -#ifdef CATCH_CONFIG_VARIADIC_MACROS - #define INTERNAL_CATCH_SECTION( ... ) \ - if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) -#else - #define INTERNAL_CATCH_SECTION( name, desc ) \ - if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) ) -#endif - -// #included from: internal/catch_generators.hpp -#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED - -#include -#include -#include -#include - -namespace Catch { - -template -struct IGenerator { - virtual ~IGenerator() {} - virtual T getValue( std::size_t index ) const = 0; - virtual std::size_t size () const = 0; -}; - -template -class BetweenGenerator : public IGenerator { -public: - BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} - - virtual T getValue( std::size_t index ) const { - return m_from+static_cast( index ); - } - - virtual std::size_t size() const { - return static_cast( 1+m_to-m_from ); - } - -private: - - T m_from; - T m_to; -}; - -template -class ValuesGenerator : public IGenerator { -public: - ValuesGenerator(){} - - void add( T value ) { - m_values.push_back( value ); - } - - virtual T getValue( std::size_t index ) const { - return m_values[index]; - } - - virtual std::size_t size() const { - return m_values.size(); - } - -private: - std::vector m_values; -}; - -template -class CompositeGenerator { -public: - CompositeGenerator() : m_totalSize( 0 ) {} - - // *** Move semantics, similar to auto_ptr *** - CompositeGenerator( CompositeGenerator& other ) - : m_fileInfo( other.m_fileInfo ), - m_totalSize( 0 ) - { - move( other ); - } - - CompositeGenerator& setFileInfo( const char* fileInfo ) { - m_fileInfo = fileInfo; - return *this; - } - - ~CompositeGenerator() { - deleteAll( m_composed ); - } - - operator T () const { - size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); - - typename std::vector*>::const_iterator it = m_composed.begin(); - typename std::vector*>::const_iterator itEnd = m_composed.end(); - for( size_t index = 0; it != itEnd; ++it ) - { - const IGenerator* generator = *it; - if( overallIndex >= index && overallIndex < index + generator->size() ) - { - return generator->getValue( overallIndex-index ); - } - index += generator->size(); - } - CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); - return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so - } - - void add( const IGenerator* generator ) { - m_totalSize += generator->size(); - m_composed.push_back( generator ); - } - - CompositeGenerator& then( CompositeGenerator& other ) { - move( other ); - return *this; - } - - CompositeGenerator& then( T value ) { - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( value ); - add( valuesGen ); - return *this; - } - -private: - - void move( CompositeGenerator& other ) { - std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); - m_totalSize += other.m_totalSize; - other.m_composed.clear(); - } - - std::vector*> m_composed; - std::string m_fileInfo; - size_t m_totalSize; -}; - -namespace Generators -{ - template - CompositeGenerator between( T from, T to ) { - CompositeGenerator generators; - generators.add( new BetweenGenerator( from, to ) ); - return generators; - } - - template - CompositeGenerator values( T val1, T val2 ) { - CompositeGenerator generators; - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( val1 ); - valuesGen->add( val2 ); - generators.add( valuesGen ); - return generators; - } - - template - CompositeGenerator values( T val1, T val2, T val3 ){ - CompositeGenerator generators; - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( val1 ); - valuesGen->add( val2 ); - valuesGen->add( val3 ); - generators.add( valuesGen ); - return generators; - } - - template - CompositeGenerator values( T val1, T val2, T val3, T val4 ) { - CompositeGenerator generators; - ValuesGenerator* valuesGen = new ValuesGenerator(); - valuesGen->add( val1 ); - valuesGen->add( val2 ); - valuesGen->add( val3 ); - valuesGen->add( val4 ); - generators.add( valuesGen ); - return generators; - } - -} // end namespace Generators - -using namespace Generators; - -} // end namespace Catch - -#define INTERNAL_CATCH_LINESTR2( line ) #line -#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) - -#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) - -// #included from: internal/catch_interfaces_exception.h -#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED - -#include -// #included from: catch_interfaces_registry_hub.h -#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED - -#include - -namespace Catch { - - class TestCase; - struct ITestCaseRegistry; - struct IExceptionTranslatorRegistry; - struct IExceptionTranslator; - struct IReporterRegistry; - struct IReporterFactory; - - struct IRegistryHub { - virtual ~IRegistryHub(); - - virtual IReporterRegistry const& getReporterRegistry() const = 0; - virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; - virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0; - }; - - struct IMutableRegistryHub { - virtual ~IMutableRegistryHub(); - virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0; - virtual void registerTest( TestCase const& testInfo ) = 0; - virtual void registerTranslator( const IExceptionTranslator* translator ) = 0; - }; - - IRegistryHub& getRegistryHub(); - IMutableRegistryHub& getMutableRegistryHub(); - void cleanUp(); - std::string translateActiveException(); - -} - - -namespace Catch { - - typedef std::string(*exceptionTranslateFunction)(); - - struct IExceptionTranslator { - virtual ~IExceptionTranslator(); - virtual std::string translate() const = 0; - }; - - struct IExceptionTranslatorRegistry { - virtual ~IExceptionTranslatorRegistry(); - - virtual std::string translateActiveException() const = 0; - }; - - class ExceptionTranslatorRegistrar { - template - class ExceptionTranslator : public IExceptionTranslator { - public: - - ExceptionTranslator( std::string(*translateFunction)( T& ) ) - : m_translateFunction( translateFunction ) - {} - - virtual std::string translate() const { - try { - throw; - } - catch( T& ex ) { - return m_translateFunction( ex ); - } - } - - protected: - std::string(*m_translateFunction)( T& ); - }; - - public: - template - ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) { - getMutableRegistryHub().registerTranslator - ( new ExceptionTranslator( translateFunction ) ); - } - }; -} - -/////////////////////////////////////////////////////////////////////////////// -#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \ - static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \ - namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\ - static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ) - -// #included from: internal/catch_approx.hpp -#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED - -#include -#include - -namespace Catch { -namespace Detail { - - class Approx { - public: - explicit Approx ( double value ) - : m_epsilon( std::numeric_limits::epsilon()*100 ), - m_scale( 1.0 ), - m_value( value ) - {} - - Approx( Approx const& other ) - : m_epsilon( other.m_epsilon ), - m_scale( other.m_scale ), - m_value( other.m_value ) - {} - - static Approx custom() { - return Approx( 0 ); - } - - Approx operator()( double value ) { - Approx approx( value ); - approx.epsilon( m_epsilon ); - approx.scale( m_scale ); - return approx; - } - - friend bool operator == ( double lhs, Approx const& rhs ) { - // Thanks to Richard Harris for his help refining this formula - return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) ); - } - - friend bool operator == ( Approx const& lhs, double rhs ) { - return operator==( rhs, lhs ); - } - - friend bool operator != ( double lhs, Approx const& rhs ) { - return !operator==( lhs, rhs ); - } - - friend bool operator != ( Approx const& lhs, double rhs ) { - return !operator==( rhs, lhs ); - } - - Approx& epsilon( double newEpsilon ) { - m_epsilon = newEpsilon; - return *this; - } - - Approx& scale( double newScale ) { - m_scale = newScale; - return *this; - } - - std::string toString() const { - std::ostringstream oss; - oss << "Approx( " << Catch::toString( m_value ) << " )"; - return oss.str(); - } - - private: - double m_epsilon; - double m_scale; - double m_value; - }; -} - -template<> -inline std::string toString( Detail::Approx const& value ) { - return value.toString(); -} - -} // end namespace Catch - -// #included from: internal/catch_matchers.hpp -#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED - -namespace Catch { -namespace Matchers { - namespace Impl { - - template - struct Matcher : SharedImpl - { - typedef ExpressionT ExpressionType; - - virtual ~Matcher() {} - virtual Ptr clone() const = 0; - virtual bool match( ExpressionT const& expr ) const = 0; - virtual std::string toString() const = 0; - }; - - template - struct MatcherImpl : Matcher { - - virtual Ptr > clone() const { - return Ptr >( new DerivedT( static_cast( *this ) ) ); - } - }; - - namespace Generic { - - template - class AllOf : public MatcherImpl, ExpressionT> { - public: - - AllOf() {} - AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {} - - AllOf& add( Matcher const& matcher ) { - m_matchers.push_back( matcher.clone() ); - return *this; - } - virtual bool match( ExpressionT const& expr ) const - { - for( std::size_t i = 0; i < m_matchers.size(); ++i ) - if( !m_matchers[i]->match( expr ) ) - return false; - return true; - } - virtual std::string toString() const { - std::ostringstream oss; - oss << "( "; - for( std::size_t i = 0; i < m_matchers.size(); ++i ) { - if( i != 0 ) - oss << " and "; - oss << m_matchers[i]->toString(); - } - oss << " )"; - return oss.str(); - } - - private: - std::vector > > m_matchers; - }; - - template - class AnyOf : public MatcherImpl, ExpressionT> { - public: - - AnyOf() {} - AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {} - - AnyOf& add( Matcher const& matcher ) { - m_matchers.push_back( matcher.clone() ); - return *this; - } - virtual bool match( ExpressionT const& expr ) const - { - for( std::size_t i = 0; i < m_matchers.size(); ++i ) - if( m_matchers[i]->match( expr ) ) - return true; - return false; - } - virtual std::string toString() const { - std::ostringstream oss; - oss << "( "; - for( std::size_t i = 0; i < m_matchers.size(); ++i ) { - if( i != 0 ) - oss << " or "; - oss << m_matchers[i]->toString(); - } - oss << " )"; - return oss.str(); - } - - private: - std::vector > > m_matchers; - }; - - } - - namespace StdString { - - inline std::string makeString( std::string const& str ) { return str; } - inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); } - - struct Equals : MatcherImpl { - Equals( std::string const& str ) : m_str( str ){} - Equals( Equals const& other ) : m_str( other.m_str ){} - - virtual ~Equals(); - - virtual bool match( std::string const& expr ) const { - return m_str == expr; - } - virtual std::string toString() const { - return "equals: \"" + m_str + "\""; - } - - std::string m_str; - }; - - struct Contains : MatcherImpl { - Contains( std::string const& substr ) : m_substr( substr ){} - Contains( Contains const& other ) : m_substr( other.m_substr ){} - - virtual ~Contains(); - - virtual bool match( std::string const& expr ) const { - return expr.find( m_substr ) != std::string::npos; - } - virtual std::string toString() const { - return "contains: \"" + m_substr + "\""; - } - - std::string m_substr; - }; - - struct StartsWith : MatcherImpl { - StartsWith( std::string const& substr ) : m_substr( substr ){} - StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){} - - virtual ~StartsWith(); - - virtual bool match( std::string const& expr ) const { - return expr.find( m_substr ) == 0; - } - virtual std::string toString() const { - return "starts with: \"" + m_substr + "\""; - } - - std::string m_substr; - }; - - struct EndsWith : MatcherImpl { - EndsWith( std::string const& substr ) : m_substr( substr ){} - EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){} - - virtual ~EndsWith(); - - virtual bool match( std::string const& expr ) const { - return expr.find( m_substr ) == expr.size() - m_substr.size(); - } - virtual std::string toString() const { - return "ends with: \"" + m_substr + "\""; - } - - std::string m_substr; - }; - } // namespace StdString - } // namespace Impl - - // The following functions create the actual matcher objects. - // This allows the types to be inferred - template - inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, - Impl::Matcher const& m2 ) { - return Impl::Generic::AllOf().add( m1 ).add( m2 ); - } - template - inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, - Impl::Matcher const& m2, - Impl::Matcher const& m3 ) { - return Impl::Generic::AllOf().add( m1 ).add( m2 ).add( m3 ); - } - template - inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, - Impl::Matcher const& m2 ) { - return Impl::Generic::AnyOf().add( m1 ).add( m2 ); - } - template - inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, - Impl::Matcher const& m2, - Impl::Matcher const& m3 ) { - return Impl::Generic::AnyOf().add( m1 ).add( m2 ).add( m3 ); - } - - inline Impl::StdString::Equals Equals( std::string const& str ) { - return Impl::StdString::Equals( str ); - } - inline Impl::StdString::Equals Equals( const char* str ) { - return Impl::StdString::Equals( Impl::StdString::makeString( str ) ); - } - inline Impl::StdString::Contains Contains( std::string const& substr ) { - return Impl::StdString::Contains( substr ); - } - inline Impl::StdString::Contains Contains( const char* substr ) { - return Impl::StdString::Contains( Impl::StdString::makeString( substr ) ); - } - inline Impl::StdString::StartsWith StartsWith( std::string const& substr ) { - return Impl::StdString::StartsWith( substr ); - } - inline Impl::StdString::StartsWith StartsWith( const char* substr ) { - return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) ); - } - inline Impl::StdString::EndsWith EndsWith( std::string const& substr ) { - return Impl::StdString::EndsWith( substr ); - } - inline Impl::StdString::EndsWith EndsWith( const char* substr ) { - return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) ); - } - -} // namespace Matchers - -using namespace Matchers; - -} // namespace Catch - -// #included from: internal/catch_interfaces_tag_alias_registry.h -#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED - -// #included from: catch_tag_alias.h -#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED - -#include - -namespace Catch { - - struct TagAlias { - TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {} - - std::string tag; - SourceLineInfo lineInfo; - }; - - struct RegistrarForTagAliases { - RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); - }; - -} // end namespace Catch - -#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } -// #included from: catch_option.hpp -#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED - -namespace Catch { - - // An optional type - template - class Option { - public: - Option() : nullableValue( NULL ) {} - Option( T const& _value ) - : nullableValue( new( storage ) T( _value ) ) - {} - Option( Option const& _other ) - : nullableValue( _other ? new( storage ) T( *_other ) : NULL ) - {} - - ~Option() { - reset(); - } - - Option& operator= ( Option const& _other ) { - if( &_other != this ) { - reset(); - if( _other ) - nullableValue = new( storage ) T( *_other ); - } - return *this; - } - Option& operator = ( T const& _value ) { - reset(); - nullableValue = new( storage ) T( _value ); - return *this; - } - - void reset() { - if( nullableValue ) - nullableValue->~T(); - nullableValue = NULL; - } - - T& operator*() { return *nullableValue; } - T const& operator*() const { return *nullableValue; } - T* operator->() { return nullableValue; } - const T* operator->() const { return nullableValue; } - - T valueOr( T const& defaultValue ) const { - return nullableValue ? *nullableValue : defaultValue; - } - - bool some() const { return nullableValue != NULL; } - bool none() const { return nullableValue == NULL; } - - bool operator !() const { return nullableValue == NULL; } - operator SafeBool::type() const { - return SafeBool::makeSafe( some() ); - } - - private: - T* nullableValue; - char storage[sizeof(T)]; - }; - -} // end namespace Catch - -namespace Catch { - - struct ITagAliasRegistry { - virtual ~ITagAliasRegistry(); - virtual Option find( std::string const& alias ) const = 0; - virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0; - - static ITagAliasRegistry const& get(); - }; - -} // end namespace Catch - -// These files are included here so the single_include script doesn't put them -// in the conditionally compiled sections -// #included from: internal/catch_test_case_info.h -#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED - -#include -#include - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wpadded" -#endif - -namespace Catch { - - struct ITestCase; - - struct TestCaseInfo { - enum SpecialProperties{ - None = 0, - IsHidden = 1 << 1, - ShouldFail = 1 << 2, - MayFail = 1 << 3, - Throws = 1 << 4 - }; - - TestCaseInfo( std::string const& _name, - std::string const& _className, - std::string const& _description, - std::set const& _tags, - SourceLineInfo const& _lineInfo ); - - TestCaseInfo( TestCaseInfo const& other ); - - bool isHidden() const; - bool throws() const; - bool okToFail() const; - bool expectedToFail() const; - - std::string name; - std::string className; - std::string description; - std::set tags; - std::set lcaseTags; - std::string tagsAsString; - SourceLineInfo lineInfo; - SpecialProperties properties; - }; - - class TestCase : public TestCaseInfo { - public: - - TestCase( ITestCase* testCase, TestCaseInfo const& info ); - TestCase( TestCase const& other ); - - TestCase withName( std::string const& _newName ) const; - - void invoke() const; - - TestCaseInfo const& getTestCaseInfo() const; - - void swap( TestCase& other ); - bool operator == ( TestCase const& other ) const; - bool operator < ( TestCase const& other ) const; - TestCase& operator = ( TestCase const& other ); - - private: - Ptr test; - }; - - TestCase makeTestCase( ITestCase* testCase, - std::string const& className, - std::string const& name, - std::string const& description, - SourceLineInfo const& lineInfo ); -} - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - - -#ifdef __OBJC__ -// #included from: internal/catch_objc.hpp -#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED - -#import - -#include - -// NB. Any general catch headers included here must be included -// in catch.hpp first to make sure they are included by the single -// header for non obj-usage - -/////////////////////////////////////////////////////////////////////////////// -// This protocol is really only here for (self) documenting purposes, since -// all its methods are optional. -@protocol OcFixture - -@optional - --(void) setUp; --(void) tearDown; - -@end - -namespace Catch { - - class OcMethod : public SharedImpl { - - public: - OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {} - - virtual void invoke() const { - id obj = [[m_cls alloc] init]; - - performOptionalSelector( obj, @selector(setUp) ); - performOptionalSelector( obj, m_sel ); - performOptionalSelector( obj, @selector(tearDown) ); - - arcSafeRelease( obj ); - } - private: - virtual ~OcMethod() {} - - Class m_cls; - SEL m_sel; - }; - - namespace Detail{ - - inline std::string getAnnotation( Class cls, - std::string const& annotationName, - std::string const& testCaseName ) { - NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()]; - SEL sel = NSSelectorFromString( selStr ); - arcSafeRelease( selStr ); - id value = performOptionalSelector( cls, sel ); - if( value ) - return [(NSString*)value UTF8String]; - return ""; - } - } - - inline size_t registerTestMethods() { - size_t noTestMethods = 0; - int noClasses = objc_getClassList( NULL, 0 ); - - Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses); - objc_getClassList( classes, noClasses ); - - for( int c = 0; c < noClasses; c++ ) { - Class cls = classes[c]; - { - u_int count; - Method* methods = class_copyMethodList( cls, &count ); - for( u_int m = 0; m < count ; m++ ) { - SEL selector = method_getName(methods[m]); - std::string methodName = sel_getName(selector); - if( startsWith( methodName, "Catch_TestCase_" ) ) { - std::string testCaseName = methodName.substr( 15 ); - std::string name = Detail::getAnnotation( cls, "Name", testCaseName ); - std::string desc = Detail::getAnnotation( cls, "Description", testCaseName ); - const char* className = class_getName( cls ); - - getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) ); - noTestMethods++; - } - } - free(methods); - } - } - return noTestMethods; - } - - namespace Matchers { - namespace Impl { - namespace NSStringMatchers { - - template - struct StringHolder : MatcherImpl{ - StringHolder( NSString* substr ) : m_substr( [substr copy] ){} - StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){} - StringHolder() { - arcSafeRelease( m_substr ); - } - - NSString* m_substr; - }; - - struct Equals : StringHolder { - Equals( NSString* substr ) : StringHolder( substr ){} - - virtual bool match( ExpressionType const& str ) const { - return (str != nil || m_substr == nil ) && - [str isEqualToString:m_substr]; - } - - virtual std::string toString() const { - return "equals string: " + Catch::toString( m_substr ); - } - }; - - struct Contains : StringHolder { - Contains( NSString* substr ) : StringHolder( substr ){} - - virtual bool match( ExpressionType const& str ) const { - return (str != nil || m_substr == nil ) && - [str rangeOfString:m_substr].location != NSNotFound; - } - - virtual std::string toString() const { - return "contains string: " + Catch::toString( m_substr ); - } - }; - - struct StartsWith : StringHolder { - StartsWith( NSString* substr ) : StringHolder( substr ){} - - virtual bool match( ExpressionType const& str ) const { - return (str != nil || m_substr == nil ) && - [str rangeOfString:m_substr].location == 0; - } - - virtual std::string toString() const { - return "starts with: " + Catch::toString( m_substr ); - } - }; - struct EndsWith : StringHolder { - EndsWith( NSString* substr ) : StringHolder( substr ){} - - virtual bool match( ExpressionType const& str ) const { - return (str != nil || m_substr == nil ) && - [str rangeOfString:m_substr].location == [str length] - [m_substr length]; - } - - virtual std::string toString() const { - return "ends with: " + Catch::toString( m_substr ); - } - }; - - } // namespace NSStringMatchers - } // namespace Impl - - inline Impl::NSStringMatchers::Equals - Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); } - - inline Impl::NSStringMatchers::Contains - Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); } - - inline Impl::NSStringMatchers::StartsWith - StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); } - - inline Impl::NSStringMatchers::EndsWith - EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); } - - } // namespace Matchers - - using namespace Matchers; - -} // namespace Catch - -/////////////////////////////////////////////////////////////////////////////// -#define OC_TEST_CASE( name, desc )\ -+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \ -{\ -return @ name; \ -}\ -+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \ -{ \ -return @ desc; \ -} \ --(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test ) - -#endif - -#ifdef CATCH_IMPL -// #included from: internal/catch_impl.hpp -#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED - -// Collect all the implementation files together here -// These are the equivalent of what would usually be cpp files - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wweak-vtables" -#endif - -// #included from: ../catch_runner.hpp -#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED - -// #included from: internal/catch_commandline.hpp -#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED - -// #included from: catch_config.hpp -#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED - -// #included from: catch_test_spec_parser.hpp -#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wpadded" -#endif - -// #included from: catch_test_spec.hpp -#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wpadded" -#endif - -#include -#include - -namespace Catch { - - class TestSpec { - struct Pattern : SharedImpl<> { - virtual ~Pattern(); - virtual bool matches( TestCaseInfo const& testCase ) const = 0; - }; - class NamePattern : public Pattern { - enum WildcardPosition { - NoWildcard = 0, - WildcardAtStart = 1, - WildcardAtEnd = 2, - WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd - }; - - public: - NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) { - if( startsWith( m_name, "*" ) ) { - m_name = m_name.substr( 1 ); - m_wildcard = WildcardAtStart; - } - if( endsWith( m_name, "*" ) ) { - m_name = m_name.substr( 0, m_name.size()-1 ); - m_wildcard = static_cast( m_wildcard | WildcardAtEnd ); - } - } - virtual ~NamePattern(); - virtual bool matches( TestCaseInfo const& testCase ) const { - switch( m_wildcard ) { - case NoWildcard: - return m_name == toLower( testCase.name ); - case WildcardAtStart: - return endsWith( toLower( testCase.name ), m_name ); - case WildcardAtEnd: - return startsWith( toLower( testCase.name ), m_name ); - case WildcardAtBothEnds: - return contains( toLower( testCase.name ), m_name ); - } - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunreachable-code" -#endif - throw std::logic_error( "Unknown enum" ); -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - } - private: - std::string m_name; - WildcardPosition m_wildcard; - }; - class TagPattern : public Pattern { - public: - TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {} - virtual ~TagPattern(); - virtual bool matches( TestCaseInfo const& testCase ) const { - return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end(); - } - private: - std::string m_tag; - }; - class ExcludedPattern : public Pattern { - public: - ExcludedPattern( Ptr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {} - virtual ~ExcludedPattern(); - virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); } - private: - Ptr m_underlyingPattern; - }; - - struct Filter { - std::vector > m_patterns; - - bool matches( TestCaseInfo const& testCase ) const { - // All patterns in a filter must match for the filter to be a match - for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) - if( !(*it)->matches( testCase ) ) - return false; - return true; - } - }; - - public: - bool hasFilters() const { - return !m_filters.empty(); - } - bool matches( TestCaseInfo const& testCase ) const { - // A TestSpec matches if any filter matches - for( std::vector::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it ) - if( it->matches( testCase ) ) - return true; - return false; - } - - private: - std::vector m_filters; - - friend class TestSpecParser; - }; -} - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -namespace Catch { - - class TestSpecParser { - enum Mode{ None, Name, QuotedName, Tag }; - Mode m_mode; - bool m_exclusion; - std::size_t m_start, m_pos; - std::string m_arg; - TestSpec::Filter m_currentFilter; - TestSpec m_testSpec; - ITagAliasRegistry const* m_tagAliases; - - public: - TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {} - - TestSpecParser& parse( std::string const& arg ) { - m_mode = None; - m_exclusion = false; - m_start = std::string::npos; - m_arg = m_tagAliases->expandAliases( arg ); - for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) - visitChar( m_arg[m_pos] ); - if( m_mode == Name ) - addPattern(); - return *this; - } - TestSpec testSpec() { - addFilter(); - return m_testSpec; - } - private: - void visitChar( char c ) { - if( m_mode == None ) { - switch( c ) { - case ' ': return; - case '~': m_exclusion = true; return; - case '[': return startNewMode( Tag, ++m_pos ); - case '"': return startNewMode( QuotedName, ++m_pos ); - default: startNewMode( Name, m_pos ); break; - } - } - if( m_mode == Name ) { - if( c == ',' ) { - addPattern(); - addFilter(); - } - else if( c == '[' ) { - if( subString() == "exclude:" ) - m_exclusion = true; - else - addPattern(); - startNewMode( Tag, ++m_pos ); - } - } - else if( m_mode == QuotedName && c == '"' ) - addPattern(); - else if( m_mode == Tag && c == ']' ) - addPattern(); - } - void startNewMode( Mode mode, std::size_t start ) { - m_mode = mode; - m_start = start; - } - std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); } - template - void addPattern() { - std::string token = subString(); - if( startsWith( token, "exclude:" ) ) { - m_exclusion = true; - token = token.substr( 8 ); - } - if( !token.empty() ) { - Ptr pattern = new T( token ); - if( m_exclusion ) - pattern = new TestSpec::ExcludedPattern( pattern ); - m_currentFilter.m_patterns.push_back( pattern ); - } - m_exclusion = false; - m_mode = None; - } - void addFilter() { - if( !m_currentFilter.m_patterns.empty() ) { - m_testSpec.m_filters.push_back( m_currentFilter ); - m_currentFilter = TestSpec::Filter(); - } - } - }; - inline TestSpec parseTestSpec( std::string const& arg ) { - return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec(); - } - -} // namespace Catch - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -// #included from: catch_interfaces_config.h -#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED - -#include -#include -#include - -namespace Catch { - - struct Verbosity { enum Level { - NoOutput = 0, - Quiet, - Normal - }; }; - - struct WarnAbout { enum What { - Nothing = 0x00, - NoAssertions = 0x01 - }; }; - - struct ShowDurations { enum OrNot { - DefaultForReporter, - Always, - Never - }; }; - struct RunTests { enum InWhatOrder { - InDeclarationOrder, - InLexicographicalOrder, - InRandomOrder - }; }; - - class TestSpec; - - struct IConfig : IShared { - - virtual ~IConfig(); - - virtual bool allowThrows() const = 0; - virtual std::ostream& stream() const = 0; - virtual std::string name() const = 0; - virtual bool includeSuccessfulResults() const = 0; - virtual bool shouldDebugBreak() const = 0; - virtual bool warnAboutMissingAssertions() const = 0; - virtual int abortAfter() const = 0; - virtual bool showInvisibles() const = 0; - virtual ShowDurations::OrNot showDurations() const = 0; - virtual TestSpec const& testSpec() const = 0; - virtual RunTests::InWhatOrder runOrder() const = 0; - virtual unsigned int rngSeed() const = 0; - virtual bool forceColour() const = 0; - }; -} - -// #included from: catch_stream.h -#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED - -#include - -#ifdef __clang__ -#pragma clang diagnostic ignored "-Wpadded" -#endif - -namespace Catch { - - class Stream { - public: - Stream(); - Stream( std::streambuf* _streamBuf, bool _isOwned ); - void release(); - - std::streambuf* streamBuf; - - private: - bool isOwned; - }; - - std::ostream& cout(); - std::ostream& cerr(); -} - -#include -#include -#include -#include -#include - -#ifndef CATCH_CONFIG_CONSOLE_WIDTH -#define CATCH_CONFIG_CONSOLE_WIDTH 80 -#endif - -namespace Catch { - - struct ConfigData { - - ConfigData() - : listTests( false ), - listTags( false ), - listReporters( false ), - listTestNamesOnly( false ), - showSuccessfulTests( false ), - shouldDebugBreak( false ), - noThrow( false ), - showHelp( false ), - showInvisibles( false ), - forceColour( false ), - abortAfter( -1 ), - rngSeed( 0 ), - verbosity( Verbosity::Normal ), - warnings( WarnAbout::Nothing ), - showDurations( ShowDurations::DefaultForReporter ), - runOrder( RunTests::InDeclarationOrder ) - {} - - bool listTests; - bool listTags; - bool listReporters; - bool listTestNamesOnly; - - bool showSuccessfulTests; - bool shouldDebugBreak; - bool noThrow; - bool showHelp; - bool showInvisibles; - bool forceColour; - - int abortAfter; - unsigned int rngSeed; - - Verbosity::Level verbosity; - WarnAbout::What warnings; - ShowDurations::OrNot showDurations; - RunTests::InWhatOrder runOrder; - - std::string reporterName; - std::string outputFilename; - std::string name; - std::string processName; - - std::vector testsOrTags; - }; - - class Config : public SharedImpl { - private: - Config( Config const& other ); - Config& operator = ( Config const& other ); - virtual void dummy(); - public: - - Config() - : m_os( Catch::cout().rdbuf() ) - {} - - Config( ConfigData const& data ) - : m_data( data ), - m_os( Catch::cout().rdbuf() ) - { - if( !data.testsOrTags.empty() ) { - TestSpecParser parser( ITagAliasRegistry::get() ); - for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) - parser.parse( data.testsOrTags[i] ); - m_testSpec = parser.testSpec(); - } - } - - virtual ~Config() { - m_os.rdbuf( Catch::cout().rdbuf() ); - m_stream.release(); - } - - void setFilename( std::string const& filename ) { - m_data.outputFilename = filename; - } - - std::string const& getFilename() const { - return m_data.outputFilename ; - } - - bool listTests() const { return m_data.listTests; } - bool listTestNamesOnly() const { return m_data.listTestNamesOnly; } - bool listTags() const { return m_data.listTags; } - bool listReporters() const { return m_data.listReporters; } - - std::string getProcessName() const { return m_data.processName; } - - bool shouldDebugBreak() const { return m_data.shouldDebugBreak; } - - void setStreamBuf( std::streambuf* buf ) { - m_os.rdbuf( buf ? buf : Catch::cout().rdbuf() ); - } - - void useStream( std::string const& streamName ) { - Stream stream = createStream( streamName ); - setStreamBuf( stream.streamBuf ); - m_stream.release(); - m_stream = stream; - } - - std::string getReporterName() const { return m_data.reporterName; } - - int abortAfter() const { return m_data.abortAfter; } - - TestSpec const& testSpec() const { return m_testSpec; } - - bool showHelp() const { return m_data.showHelp; } - bool showInvisibles() const { return m_data.showInvisibles; } - - // IConfig interface - virtual bool allowThrows() const { return !m_data.noThrow; } - virtual std::ostream& stream() const { return m_os; } - virtual std::string name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } - virtual bool includeSuccessfulResults() const { return m_data.showSuccessfulTests; } - virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; } - virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; } - virtual RunTests::InWhatOrder runOrder() const { return m_data.runOrder; } - virtual unsigned int rngSeed() const { return m_data.rngSeed; } - virtual bool forceColour() const { return m_data.forceColour; } - - private: - ConfigData m_data; - - Stream m_stream; - mutable std::ostream m_os; - TestSpec m_testSpec; - }; - -} // end namespace Catch - -// #included from: catch_clara.h -#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED - -// Use Catch's value for console width (store Clara's off to the side, if present) -#ifdef CLARA_CONFIG_CONSOLE_WIDTH -#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH -#undef CLARA_CONFIG_CONSOLE_WIDTH -#endif -#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH - -// Declare Clara inside the Catch namespace -#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch { -// #included from: ../external/clara.h - -// Only use header guard if we are not using an outer namespace -#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE) - -#ifndef STITCH_CLARA_OPEN_NAMESPACE -#define TWOBLUECUBES_CLARA_H_INCLUDED -#define STITCH_CLARA_OPEN_NAMESPACE -#define STITCH_CLARA_CLOSE_NAMESPACE -#else -#define STITCH_CLARA_CLOSE_NAMESPACE } -#endif - -#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE - -// ----------- #included from tbc_text_format.h ----------- - -// Only use header guard if we are not using an outer namespace -#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE) -#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE -#define TBC_TEXT_FORMAT_H_INCLUDED -#endif - -#include -#include -#include - -// Use optional outer namespace -#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE -namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE { -#endif - -namespace Tbc { - -#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH - const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; -#else - const unsigned int consoleWidth = 80; -#endif - - struct TextAttributes { - TextAttributes() - : initialIndent( std::string::npos ), - indent( 0 ), - width( consoleWidth-1 ), - tabChar( '\t' ) - {} - - TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } - TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } - TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } - TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } - - std::size_t initialIndent; // indent of first line, or npos - std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos - std::size_t width; // maximum width of text, including indent. Longer text will wrap - char tabChar; // If this char is seen the indent is changed to current pos - }; - - class Text { - public: - Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) - : attr( _attr ) - { - std::string wrappableChars = " [({.,/|\\-"; - std::size_t indent = _attr.initialIndent != std::string::npos - ? _attr.initialIndent - : _attr.indent; - std::string remainder = _str; - - while( !remainder.empty() ) { - if( lines.size() >= 1000 ) { - lines.push_back( "... message truncated due to excessive size" ); - return; - } - std::size_t tabPos = std::string::npos; - std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); - std::size_t pos = remainder.find_first_of( '\n' ); - if( pos <= width ) { - width = pos; - } - pos = remainder.find_last_of( _attr.tabChar, width ); - if( pos != std::string::npos ) { - tabPos = pos; - if( remainder[width] == '\n' ) - width--; - remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); - } - - if( width == remainder.size() ) { - spliceLine( indent, remainder, width ); - } - else if( remainder[width] == '\n' ) { - spliceLine( indent, remainder, width ); - if( width <= 1 || remainder.size() != 1 ) - remainder = remainder.substr( 1 ); - indent = _attr.indent; - } - else { - pos = remainder.find_last_of( wrappableChars, width ); - if( pos != std::string::npos && pos > 0 ) { - spliceLine( indent, remainder, pos ); - if( remainder[0] == ' ' ) - remainder = remainder.substr( 1 ); - } - else { - spliceLine( indent, remainder, width-1 ); - lines.back() += "-"; - } - if( lines.size() == 1 ) - indent = _attr.indent; - if( tabPos != std::string::npos ) - indent += tabPos; - } - } - } - - void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { - lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); - _remainder = _remainder.substr( _pos ); - } - - typedef std::vector::const_iterator const_iterator; - - const_iterator begin() const { return lines.begin(); } - const_iterator end() const { return lines.end(); } - std::string const& last() const { return lines.back(); } - std::size_t size() const { return lines.size(); } - std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } - std::string toString() const { - std::ostringstream oss; - oss << *this; - return oss.str(); - } - - inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { - for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); - it != itEnd; ++it ) { - if( it != _text.begin() ) - _stream << "\n"; - _stream << *it; - } - return _stream; - } - - private: - std::string str; - TextAttributes attr; - std::vector lines; - }; - -} // end namespace Tbc - -#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE -} // end outer namespace -#endif - -#endif // TBC_TEXT_FORMAT_H_INCLUDED - -// ----------- end of #include from tbc_text_format.h ----------- -// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h - -#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE - -#include -#include -#include -#include - -// Use optional outer namespace -#ifdef STITCH_CLARA_OPEN_NAMESPACE -STITCH_CLARA_OPEN_NAMESPACE -#endif - -namespace Clara { - - struct UnpositionalTag {}; - - extern UnpositionalTag _; - -#ifdef CLARA_CONFIG_MAIN - UnpositionalTag _; -#endif - - namespace Detail { - -#ifdef CLARA_CONSOLE_WIDTH - const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; -#else - const unsigned int consoleWidth = 80; -#endif - - using namespace Tbc; - - inline bool startsWith( std::string const& str, std::string const& prefix ) { - return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix; - } - - template struct RemoveConstRef{ typedef T type; }; - template struct RemoveConstRef{ typedef T type; }; - template struct RemoveConstRef{ typedef T type; }; - template struct RemoveConstRef{ typedef T type; }; - - template struct IsBool { static const bool value = false; }; - template<> struct IsBool { static const bool value = true; }; - - template - void convertInto( std::string const& _source, T& _dest ) { - std::stringstream ss; - ss << _source; - ss >> _dest; - if( ss.fail() ) - throw std::runtime_error( "Unable to convert " + _source + " to destination type" ); - } - inline void convertInto( std::string const& _source, std::string& _dest ) { - _dest = _source; - } - inline void convertInto( std::string const& _source, bool& _dest ) { - std::string sourceLC = _source; - std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower ); - if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ) - _dest = true; - else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" ) - _dest = false; - else - throw std::runtime_error( "Expected a boolean value but did not recognise:\n '" + _source + "'" ); - } - inline void convertInto( bool _source, bool& _dest ) { - _dest = _source; - } - template - inline void convertInto( bool, T& ) { - throw std::runtime_error( "Invalid conversion" ); - } - - template - struct IArgFunction { - virtual ~IArgFunction() {} -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - IArgFunction() = default; - IArgFunction( IArgFunction const& ) = default; -# endif - virtual void set( ConfigT& config, std::string const& value ) const = 0; - virtual void setFlag( ConfigT& config ) const = 0; - virtual bool takesArg() const = 0; - virtual IArgFunction* clone() const = 0; - }; - - template - class BoundArgFunction { - public: - BoundArgFunction() : functionObj( NULL ) {} - BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {} - BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : NULL ) {} - BoundArgFunction& operator = ( BoundArgFunction const& other ) { - IArgFunction* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL; - delete functionObj; - functionObj = newFunctionObj; - return *this; - } - ~BoundArgFunction() { delete functionObj; } - - void set( ConfigT& config, std::string const& value ) const { - functionObj->set( config, value ); - } - void setFlag( ConfigT& config ) const { - functionObj->setFlag( config ); - } - bool takesArg() const { return functionObj->takesArg(); } - - bool isSet() const { - return functionObj != NULL; - } - private: - IArgFunction* functionObj; - }; - - template - struct NullBinder : IArgFunction{ - virtual void set( C&, std::string const& ) const {} - virtual void setFlag( C& ) const {} - virtual bool takesArg() const { return true; } - virtual IArgFunction* clone() const { return new NullBinder( *this ); } - }; - - template - struct BoundDataMember : IArgFunction{ - BoundDataMember( M C::* _member ) : member( _member ) {} - virtual void set( C& p, std::string const& stringValue ) const { - convertInto( stringValue, p.*member ); - } - virtual void setFlag( C& p ) const { - convertInto( true, p.*member ); - } - virtual bool takesArg() const { return !IsBool::value; } - virtual IArgFunction* clone() const { return new BoundDataMember( *this ); } - M C::* member; - }; - template - struct BoundUnaryMethod : IArgFunction{ - BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {} - virtual void set( C& p, std::string const& stringValue ) const { - typename RemoveConstRef::type value; - convertInto( stringValue, value ); - (p.*member)( value ); - } - virtual void setFlag( C& p ) const { - typename RemoveConstRef::type value; - convertInto( true, value ); - (p.*member)( value ); - } - virtual bool takesArg() const { return !IsBool::value; } - virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); } - void (C::*member)( M ); - }; - template - struct BoundNullaryMethod : IArgFunction{ - BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {} - virtual void set( C& p, std::string const& stringValue ) const { - bool value; - convertInto( stringValue, value ); - if( value ) - (p.*member)(); - } - virtual void setFlag( C& p ) const { - (p.*member)(); - } - virtual bool takesArg() const { return false; } - virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); } - void (C::*member)(); - }; - - template - struct BoundUnaryFunction : IArgFunction{ - BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {} - virtual void set( C& obj, std::string const& stringValue ) const { - bool value; - convertInto( stringValue, value ); - if( value ) - function( obj ); - } - virtual void setFlag( C& p ) const { - function( p ); - } - virtual bool takesArg() const { return false; } - virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); } - void (*function)( C& ); - }; - - template - struct BoundBinaryFunction : IArgFunction{ - BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {} - virtual void set( C& obj, std::string const& stringValue ) const { - typename RemoveConstRef::type value; - convertInto( stringValue, value ); - function( obj, value ); - } - virtual void setFlag( C& obj ) const { - typename RemoveConstRef::type value; - convertInto( true, value ); - function( obj, value ); - } - virtual bool takesArg() const { return !IsBool::value; } - virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); } - void (*function)( C&, T ); - }; - - } // namespace Detail - - struct Parser { - Parser() : separators( " \t=:" ) {} - - struct Token { - enum Type { Positional, ShortOpt, LongOpt }; - Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {} - Type type; - std::string data; - }; - - void parseIntoTokens( int argc, char const * const * argv, std::vector& tokens ) const { - const std::string doubleDash = "--"; - for( int i = 1; i < argc && argv[i] != doubleDash; ++i ) - parseIntoTokens( argv[i] , tokens); - } - void parseIntoTokens( std::string arg, std::vector& tokens ) const { - while( !arg.empty() ) { - Parser::Token token( Parser::Token::Positional, arg ); - arg = ""; - if( token.data[0] == '-' ) { - if( token.data.size() > 1 && token.data[1] == '-' ) { - token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) ); - } - else { - token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) ); - if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) { - arg = "-" + token.data.substr( 1 ); - token.data = token.data.substr( 0, 1 ); - } - } - } - if( token.type != Parser::Token::Positional ) { - std::size_t pos = token.data.find_first_of( separators ); - if( pos != std::string::npos ) { - arg = token.data.substr( pos+1 ); - token.data = token.data.substr( 0, pos ); - } - } - tokens.push_back( token ); - } - } - std::string separators; - }; - - template - struct CommonArgProperties { - CommonArgProperties() {} - CommonArgProperties( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ) {} - - Detail::BoundArgFunction boundField; - std::string description; - std::string detail; - std::string placeholder; // Only value if boundField takes an arg - - bool takesArg() const { - return !placeholder.empty(); - } - void validate() const { - if( !boundField.isSet() ) - throw std::logic_error( "option not bound" ); - } - }; - struct OptionArgProperties { - std::vector shortNames; - std::string longName; - - bool hasShortName( std::string const& shortName ) const { - return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end(); - } - bool hasLongName( std::string const& _longName ) const { - return _longName == longName; - } - }; - struct PositionalArgProperties { - PositionalArgProperties() : position( -1 ) {} - int position; // -1 means non-positional (floating) - - bool isFixedPositional() const { - return position != -1; - } - }; - - template - class CommandLine { - - struct Arg : CommonArgProperties, OptionArgProperties, PositionalArgProperties { - Arg() {} - Arg( Detail::BoundArgFunction const& _boundField ) : CommonArgProperties( _boundField ) {} - - using CommonArgProperties::placeholder; // !TBD - - std::string dbgName() const { - if( !longName.empty() ) - return "--" + longName; - if( !shortNames.empty() ) - return "-" + shortNames[0]; - return "positional args"; - } - std::string commands() const { - std::ostringstream oss; - bool first = true; - std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end(); - for(; it != itEnd; ++it ) { - if( first ) - first = false; - else - oss << ", "; - oss << "-" << *it; - } - if( !longName.empty() ) { - if( !first ) - oss << ", "; - oss << "--" << longName; - } - if( !placeholder.empty() ) - oss << " <" << placeholder << ">"; - return oss.str(); - } - }; - - // NOTE: std::auto_ptr is deprecated in c++11/c++0x -#if defined(__cplusplus) && __cplusplus > 199711L - typedef std::unique_ptr ArgAutoPtr; -#else - typedef std::auto_ptr ArgAutoPtr; -#endif - - friend void addOptName( Arg& arg, std::string const& optName ) - { - if( optName.empty() ) - return; - if( Detail::startsWith( optName, "--" ) ) { - if( !arg.longName.empty() ) - throw std::logic_error( "Only one long opt may be specified. '" - + arg.longName - + "' already specified, now attempting to add '" - + optName + "'" ); - arg.longName = optName.substr( 2 ); - } - else if( Detail::startsWith( optName, "-" ) ) - arg.shortNames.push_back( optName.substr( 1 ) ); - else - throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" ); - } - friend void setPositionalArg( Arg& arg, int position ) - { - arg.position = position; - } - - class ArgBuilder { - public: - ArgBuilder( Arg* arg ) : m_arg( arg ) {} - - // Bind a non-boolean data member (requires placeholder string) - template - void bind( M C::* field, std::string const& placeholder ) { - m_arg->boundField = new Detail::BoundDataMember( field ); - m_arg->placeholder = placeholder; - } - // Bind a boolean data member (no placeholder required) - template - void bind( bool C::* field ) { - m_arg->boundField = new Detail::BoundDataMember( field ); - } - - // Bind a method taking a single, non-boolean argument (requires a placeholder string) - template - void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) { - m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); - m_arg->placeholder = placeholder; - } - - // Bind a method taking a single, boolean argument (no placeholder string required) - template - void bind( void (C::* unaryMethod)( bool ) ) { - m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); - } - - // Bind a method that takes no arguments (will be called if opt is present) - template - void bind( void (C::* nullaryMethod)() ) { - m_arg->boundField = new Detail::BoundNullaryMethod( nullaryMethod ); - } - - // Bind a free function taking a single argument - the object to operate on (no placeholder string required) - template - void bind( void (* unaryFunction)( C& ) ) { - m_arg->boundField = new Detail::BoundUnaryFunction( unaryFunction ); - } - - // Bind a free function taking a single argument - the object to operate on (requires a placeholder string) - template - void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) { - m_arg->boundField = new Detail::BoundBinaryFunction( binaryFunction ); - m_arg->placeholder = placeholder; - } - - ArgBuilder& describe( std::string const& description ) { - m_arg->description = description; - return *this; - } - ArgBuilder& detail( std::string const& detail ) { - m_arg->detail = detail; - return *this; - } - - protected: - Arg* m_arg; - }; - - class OptBuilder : public ArgBuilder { - public: - OptBuilder( Arg* arg ) : ArgBuilder( arg ) {} - OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {} - - OptBuilder& operator[]( std::string const& optName ) { - addOptName( *ArgBuilder::m_arg, optName ); - return *this; - } - }; - - public: - - CommandLine() - : m_boundProcessName( new Detail::NullBinder() ), - m_highestSpecifiedArgPosition( 0 ), - m_throwOnUnrecognisedTokens( false ) - {} - CommandLine( CommandLine const& other ) - : m_boundProcessName( other.m_boundProcessName ), - m_options ( other.m_options ), - m_positionalArgs( other.m_positionalArgs ), - m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ), - m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens ) - { - if( other.m_floatingArg.get() ) - m_floatingArg.reset( new Arg( *other.m_floatingArg ) ); - } - - CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) { - m_throwOnUnrecognisedTokens = shouldThrow; - return *this; - } - - OptBuilder operator[]( std::string const& optName ) { - m_options.push_back( Arg() ); - addOptName( m_options.back(), optName ); - OptBuilder builder( &m_options.back() ); - return builder; - } - - ArgBuilder operator[]( int position ) { - m_positionalArgs.insert( std::make_pair( position, Arg() ) ); - if( position > m_highestSpecifiedArgPosition ) - m_highestSpecifiedArgPosition = position; - setPositionalArg( m_positionalArgs[position], position ); - ArgBuilder builder( &m_positionalArgs[position] ); - return builder; - } - - // Invoke this with the _ instance - ArgBuilder operator[]( UnpositionalTag ) { - if( m_floatingArg.get() ) - throw std::logic_error( "Only one unpositional argument can be added" ); - m_floatingArg.reset( new Arg() ); - ArgBuilder builder( m_floatingArg.get() ); - return builder; - } - - template - void bindProcessName( M C::* field ) { - m_boundProcessName = new Detail::BoundDataMember( field ); - } - template - void bindProcessName( void (C::*_unaryMethod)( M ) ) { - m_boundProcessName = new Detail::BoundUnaryMethod( _unaryMethod ); - } - - void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const { - typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it; - std::size_t maxWidth = 0; - for( it = itBegin; it != itEnd; ++it ) - maxWidth = (std::max)( maxWidth, it->commands().size() ); - - for( it = itBegin; it != itEnd; ++it ) { - Detail::Text usage( it->commands(), Detail::TextAttributes() - .setWidth( maxWidth+indent ) - .setIndent( indent ) ); - Detail::Text desc( it->description, Detail::TextAttributes() - .setWidth( width - maxWidth - 3 ) ); - - for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) { - std::string usageCol = i < usage.size() ? usage[i] : ""; - os << usageCol; - - if( i < desc.size() && !desc[i].empty() ) - os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' ) - << desc[i]; - os << "\n"; - } - } - } - std::string optUsage() const { - std::ostringstream oss; - optUsage( oss ); - return oss.str(); - } - - void argSynopsis( std::ostream& os ) const { - for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) { - if( i > 1 ) - os << " "; - typename std::map::const_iterator it = m_positionalArgs.find( i ); - if( it != m_positionalArgs.end() ) - os << "<" << it->second.placeholder << ">"; - else if( m_floatingArg.get() ) - os << "<" << m_floatingArg->placeholder << ">"; - else - throw std::logic_error( "non consecutive positional arguments with no floating args" ); - } - // !TBD No indication of mandatory args - if( m_floatingArg.get() ) { - if( m_highestSpecifiedArgPosition > 1 ) - os << " "; - os << "[<" << m_floatingArg->placeholder << "> ...]"; - } - } - std::string argSynopsis() const { - std::ostringstream oss; - argSynopsis( oss ); - return oss.str(); - } - - void usage( std::ostream& os, std::string const& procName ) const { - validate(); - os << "usage:\n " << procName << " "; - argSynopsis( os ); - if( !m_options.empty() ) { - os << " [options]\n\nwhere options are: \n"; - optUsage( os, 2 ); - } - os << "\n"; - } - std::string usage( std::string const& procName ) const { - std::ostringstream oss; - usage( oss, procName ); - return oss.str(); - } - - ConfigT parse( int argc, char const * const * argv ) const { - ConfigT config; - parseInto( argc, argv, config ); - return config; - } - - std::vector parseInto( int argc, char const * const * argv, ConfigT& config ) const { - std::string processName = argv[0]; - std::size_t lastSlash = processName.find_last_of( "/\\" ); - if( lastSlash != std::string::npos ) - processName = processName.substr( lastSlash+1 ); - m_boundProcessName.set( config, processName ); - std::vector tokens; - Parser parser; - parser.parseIntoTokens( argc, argv, tokens ); - return populate( tokens, config ); - } - - std::vector populate( std::vector const& tokens, ConfigT& config ) const { - validate(); - std::vector unusedTokens = populateOptions( tokens, config ); - unusedTokens = populateFixedArgs( unusedTokens, config ); - unusedTokens = populateFloatingArgs( unusedTokens, config ); - return unusedTokens; - } - - std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const { - std::vector unusedTokens; - std::vector errors; - for( std::size_t i = 0; i < tokens.size(); ++i ) { - Parser::Token const& token = tokens[i]; - typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); - for(; it != itEnd; ++it ) { - Arg const& arg = *it; - - try { - if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) || - ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) { - if( arg.takesArg() ) { - if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional ) - errors.push_back( "Expected argument to option: " + token.data ); - else - arg.boundField.set( config, tokens[++i].data ); - } - else { - arg.boundField.setFlag( config ); - } - break; - } - } - catch( std::exception& ex ) { - errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" ); - } - } - if( it == itEnd ) { - if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens ) - unusedTokens.push_back( token ); - else if( errors.empty() && m_throwOnUnrecognisedTokens ) - errors.push_back( "unrecognised option: " + token.data ); - } - } - if( !errors.empty() ) { - std::ostringstream oss; - for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end(); - it != itEnd; - ++it ) { - if( it != errors.begin() ) - oss << "\n"; - oss << *it; - } - throw std::runtime_error( oss.str() ); - } - return unusedTokens; - } - std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const { - std::vector unusedTokens; - int position = 1; - for( std::size_t i = 0; i < tokens.size(); ++i ) { - Parser::Token const& token = tokens[i]; - typename std::map::const_iterator it = m_positionalArgs.find( position ); - if( it != m_positionalArgs.end() ) - it->second.boundField.set( config, token.data ); - else - unusedTokens.push_back( token ); - if( token.type == Parser::Token::Positional ) - position++; - } - return unusedTokens; - } - std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const { - if( !m_floatingArg.get() ) - return tokens; - std::vector unusedTokens; - for( std::size_t i = 0; i < tokens.size(); ++i ) { - Parser::Token const& token = tokens[i]; - if( token.type == Parser::Token::Positional ) - m_floatingArg->boundField.set( config, token.data ); - else - unusedTokens.push_back( token ); - } - return unusedTokens; - } - - void validate() const - { - if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() ) - throw std::logic_error( "No options or arguments specified" ); - - for( typename std::vector::const_iterator it = m_options.begin(), - itEnd = m_options.end(); - it != itEnd; ++it ) - it->validate(); - } - - private: - Detail::BoundArgFunction m_boundProcessName; - std::vector m_options; - std::map m_positionalArgs; - ArgAutoPtr m_floatingArg; - int m_highestSpecifiedArgPosition; - bool m_throwOnUnrecognisedTokens; - }; - -} // end namespace Clara - -STITCH_CLARA_CLOSE_NAMESPACE -#undef STITCH_CLARA_OPEN_NAMESPACE -#undef STITCH_CLARA_CLOSE_NAMESPACE - -#endif // TWOBLUECUBES_CLARA_H_INCLUDED -#undef STITCH_CLARA_OPEN_NAMESPACE - -// Restore Clara's value for console width, if present -#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH -#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH -#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH -#endif - -#include - -namespace Catch { - - inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; } - inline void abortAfterX( ConfigData& config, int x ) { - if( x < 1 ) - throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" ); - config.abortAfter = x; - } - inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); } - - inline void addWarning( ConfigData& config, std::string const& _warning ) { - if( _warning == "NoAssertions" ) - config.warnings = static_cast( config.warnings | WarnAbout::NoAssertions ); - else - throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" ); - } - inline void setOrder( ConfigData& config, std::string const& order ) { - if( startsWith( "declared", order ) ) - config.runOrder = RunTests::InDeclarationOrder; - else if( startsWith( "lexical", order ) ) - config.runOrder = RunTests::InLexicographicalOrder; - else if( startsWith( "random", order ) ) - config.runOrder = RunTests::InRandomOrder; - else - throw std::runtime_error( "Unrecognised ordering: '" + order + "'" ); - } - inline void setRngSeed( ConfigData& config, std::string const& seed ) { - if( seed == "time" ) { - config.rngSeed = static_cast( std::time(0) ); - } - else { - std::stringstream ss; - ss << seed; - ss >> config.rngSeed; - if( ss.fail() ) - throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" ); - } - } - inline void setVerbosity( ConfigData& config, int level ) { - // !TBD: accept strings? - config.verbosity = static_cast( level ); - } - inline void setShowDurations( ConfigData& config, bool _showDurations ) { - config.showDurations = _showDurations - ? ShowDurations::Always - : ShowDurations::Never; - } - inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) { - std::ifstream f( _filename.c_str() ); - if( !f.is_open() ) - throw std::domain_error( "Unable to load input file: " + _filename ); - - std::string line; - while( std::getline( f, line ) ) { - line = trim(line); - if( !line.empty() && !startsWith( line, "#" ) ) - addTestOrTags( config, "\"" + line + "\"," ); - } - } - - inline Clara::CommandLine makeCommandLineParser() { - - using namespace Clara; - CommandLine cli; - - cli.bindProcessName( &ConfigData::processName ); - - cli["-?"]["-h"]["--help"] - .describe( "display usage information" ) - .bind( &ConfigData::showHelp ); - - cli["-l"]["--list-tests"] - .describe( "list all/matching test cases" ) - .bind( &ConfigData::listTests ); - - cli["-t"]["--list-tags"] - .describe( "list all/matching tags" ) - .bind( &ConfigData::listTags ); - - cli["-s"]["--success"] - .describe( "include successful tests in output" ) - .bind( &ConfigData::showSuccessfulTests ); - - cli["-b"]["--break"] - .describe( "break into debugger on failure" ) - .bind( &ConfigData::shouldDebugBreak ); - - cli["-e"]["--nothrow"] - .describe( "skip exception tests" ) - .bind( &ConfigData::noThrow ); - - cli["-i"]["--invisibles"] - .describe( "show invisibles (tabs, newlines)" ) - .bind( &ConfigData::showInvisibles ); - - cli["-o"]["--out"] - .describe( "output filename" ) - .bind( &ConfigData::outputFilename, "filename" ); - - cli["-r"]["--reporter"] -// .placeholder( "name[:filename]" ) - .describe( "reporter to use (defaults to console)" ) - .bind( &ConfigData::reporterName, "name" ); - - cli["-n"]["--name"] - .describe( "suite name" ) - .bind( &ConfigData::name, "name" ); - - cli["-a"]["--abort"] - .describe( "abort at first failure" ) - .bind( &abortAfterFirst ); - - cli["-x"]["--abortx"] - .describe( "abort after x failures" ) - .bind( &abortAfterX, "no. failures" ); - - cli["-w"]["--warn"] - .describe( "enable warnings" ) - .bind( &addWarning, "warning name" ); - -// - needs updating if reinstated -// cli.into( &setVerbosity ) -// .describe( "level of verbosity (0=no output)" ) -// .shortOpt( "v") -// .longOpt( "verbosity" ) -// .placeholder( "level" ); - - cli[_] - .describe( "which test or tests to use" ) - .bind( &addTestOrTags, "test name, pattern or tags" ); - - cli["-d"]["--durations"] - .describe( "show test durations" ) - .bind( &setShowDurations, "yes/no" ); - - cli["-f"]["--input-file"] - .describe( "load test names to run from a file" ) - .bind( &loadTestNamesFromFile, "filename" ); - - // Less common commands which don't have a short form - cli["--list-test-names-only"] - .describe( "list all/matching test cases names only" ) - .bind( &ConfigData::listTestNamesOnly ); - - cli["--list-reporters"] - .describe( "list all reporters" ) - .bind( &ConfigData::listReporters ); - - cli["--order"] - .describe( "test case order (defaults to decl)" ) - .bind( &setOrder, "decl|lex|rand" ); - - cli["--rng-seed"] - .describe( "set a specific seed for random numbers" ) - .bind( &setRngSeed, "'time'|number" ); - - cli["--force-colour"] - .describe( "force colourised output" ) - .bind( &ConfigData::forceColour ); - - return cli; - } - -} // end namespace Catch - -// #included from: internal/catch_list.hpp -#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED - -// #included from: catch_text.h -#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED - -#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH - -#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch -// #included from: ../external/tbc_text_format.h -// Only use header guard if we are not using an outer namespace -#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE -# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED -# ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED -# define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED -# endif -# else -# define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED -# endif -#endif -#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED -#include -#include -#include - -// Use optional outer namespace -#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE -namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE { -#endif - -namespace Tbc { - -#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH - const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; -#else - const unsigned int consoleWidth = 80; -#endif - - struct TextAttributes { - TextAttributes() - : initialIndent( std::string::npos ), - indent( 0 ), - width( consoleWidth-1 ), - tabChar( '\t' ) - {} - - TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } - TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } - TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } - TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } - - std::size_t initialIndent; // indent of first line, or npos - std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos - std::size_t width; // maximum width of text, including indent. Longer text will wrap - char tabChar; // If this char is seen the indent is changed to current pos - }; - - class Text { - public: - Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) - : attr( _attr ) - { - std::string wrappableChars = " [({.,/|\\-"; - std::size_t indent = _attr.initialIndent != std::string::npos - ? _attr.initialIndent - : _attr.indent; - std::string remainder = _str; - - while( !remainder.empty() ) { - if( lines.size() >= 1000 ) { - lines.push_back( "... message truncated due to excessive size" ); - return; - } - std::size_t tabPos = std::string::npos; - std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); - std::size_t pos = remainder.find_first_of( '\n' ); - if( pos <= width ) { - width = pos; - } - pos = remainder.find_last_of( _attr.tabChar, width ); - if( pos != std::string::npos ) { - tabPos = pos; - if( remainder[width] == '\n' ) - width--; - remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); - } - - if( width == remainder.size() ) { - spliceLine( indent, remainder, width ); - } - else if( remainder[width] == '\n' ) { - spliceLine( indent, remainder, width ); - if( width <= 1 || remainder.size() != 1 ) - remainder = remainder.substr( 1 ); - indent = _attr.indent; - } - else { - pos = remainder.find_last_of( wrappableChars, width ); - if( pos != std::string::npos && pos > 0 ) { - spliceLine( indent, remainder, pos ); - if( remainder[0] == ' ' ) - remainder = remainder.substr( 1 ); - } - else { - spliceLine( indent, remainder, width-1 ); - lines.back() += "-"; - } - if( lines.size() == 1 ) - indent = _attr.indent; - if( tabPos != std::string::npos ) - indent += tabPos; - } - } - } - - void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { - lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); - _remainder = _remainder.substr( _pos ); - } - - typedef std::vector::const_iterator const_iterator; - - const_iterator begin() const { return lines.begin(); } - const_iterator end() const { return lines.end(); } - std::string const& last() const { return lines.back(); } - std::size_t size() const { return lines.size(); } - std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } - std::string toString() const { - std::ostringstream oss; - oss << *this; - return oss.str(); - } - - inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { - for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); - it != itEnd; ++it ) { - if( it != _text.begin() ) - _stream << "\n"; - _stream << *it; - } - return _stream; - } - - private: - std::string str; - TextAttributes attr; - std::vector lines; - }; - -} // end namespace Tbc - -#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE -} // end outer namespace -#endif - -#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED -#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE - -namespace Catch { - using Tbc::Text; - using Tbc::TextAttributes; -} - -// #included from: catch_console_colour.hpp -#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED - -namespace Catch { - - struct Colour { - enum Code { - None = 0, - - White, - Red, - Green, - Blue, - Cyan, - Yellow, - Grey, - - Bright = 0x10, - - BrightRed = Bright | Red, - BrightGreen = Bright | Green, - LightGrey = Bright | Grey, - BrightWhite = Bright | White, - - // By intention - FileName = LightGrey, - Warning = Yellow, - ResultError = BrightRed, - ResultSuccess = BrightGreen, - ResultExpectedFailure = Warning, - - Error = BrightRed, - Success = Green, - - OriginalExpression = Cyan, - ReconstructedExpression = Yellow, - - SecondaryText = LightGrey, - Headers = White - }; - - // Use constructed object for RAII guard - Colour( Code _colourCode ); - Colour( Colour const& other ); - ~Colour(); - - // Use static method for one-shot changes - static void use( Code _colourCode ); - - private: - bool m_moved; - }; - - inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; } - -} // end namespace Catch - -// #included from: catch_interfaces_reporter.h -#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED - -#include -#include -#include -#include - -namespace Catch -{ - struct ReporterConfig { - explicit ReporterConfig( Ptr const& _fullConfig ) - : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} - - ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream ) - : m_stream( &_stream ), m_fullConfig( _fullConfig ) {} - - std::ostream& stream() const { return *m_stream; } - Ptr fullConfig() const { return m_fullConfig; } - - private: - std::ostream* m_stream; - Ptr m_fullConfig; - }; - - struct ReporterPreferences { - ReporterPreferences() - : shouldRedirectStdOut( false ) - {} - - bool shouldRedirectStdOut; - }; - - template - struct LazyStat : Option { - LazyStat() : used( false ) {} - LazyStat& operator=( T const& _value ) { - Option::operator=( _value ); - used = false; - return *this; - } - void reset() { - Option::reset(); - used = false; - } - bool used; - }; - - struct TestRunInfo { - TestRunInfo( std::string const& _name ) : name( _name ) {} - std::string name; - }; - struct GroupInfo { - GroupInfo( std::string const& _name, - std::size_t _groupIndex, - std::size_t _groupsCount ) - : name( _name ), - groupIndex( _groupIndex ), - groupsCounts( _groupsCount ) - {} - - std::string name; - std::size_t groupIndex; - std::size_t groupsCounts; - }; - - struct AssertionStats { - AssertionStats( AssertionResult const& _assertionResult, - std::vector const& _infoMessages, - Totals const& _totals ) - : assertionResult( _assertionResult ), - infoMessages( _infoMessages ), - totals( _totals ) - { - if( assertionResult.hasMessage() ) { - // Copy message into messages list. - // !TBD This should have been done earlier, somewhere - MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); - builder << assertionResult.getMessage(); - builder.m_info.message = builder.m_stream.str(); - - infoMessages.push_back( builder.m_info ); - } - } - virtual ~AssertionStats(); - -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - AssertionStats( AssertionStats const& ) = default; - AssertionStats( AssertionStats && ) = default; - AssertionStats& operator = ( AssertionStats const& ) = default; - AssertionStats& operator = ( AssertionStats && ) = default; -# endif - - AssertionResult assertionResult; - std::vector infoMessages; - Totals totals; - }; - - struct SectionStats { - SectionStats( SectionInfo const& _sectionInfo, - Counts const& _assertions, - double _durationInSeconds, - bool _missingAssertions ) - : sectionInfo( _sectionInfo ), - assertions( _assertions ), - durationInSeconds( _durationInSeconds ), - missingAssertions( _missingAssertions ) - {} - virtual ~SectionStats(); -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - SectionStats( SectionStats const& ) = default; - SectionStats( SectionStats && ) = default; - SectionStats& operator = ( SectionStats const& ) = default; - SectionStats& operator = ( SectionStats && ) = default; -# endif - - SectionInfo sectionInfo; - Counts assertions; - double durationInSeconds; - bool missingAssertions; - }; - - struct TestCaseStats { - TestCaseStats( TestCaseInfo const& _testInfo, - Totals const& _totals, - std::string const& _stdOut, - std::string const& _stdErr, - bool _aborting ) - : testInfo( _testInfo ), - totals( _totals ), - stdOut( _stdOut ), - stdErr( _stdErr ), - aborting( _aborting ) - {} - virtual ~TestCaseStats(); - -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - TestCaseStats( TestCaseStats const& ) = default; - TestCaseStats( TestCaseStats && ) = default; - TestCaseStats& operator = ( TestCaseStats const& ) = default; - TestCaseStats& operator = ( TestCaseStats && ) = default; -# endif - - TestCaseInfo testInfo; - Totals totals; - std::string stdOut; - std::string stdErr; - bool aborting; - }; - - struct TestGroupStats { - TestGroupStats( GroupInfo const& _groupInfo, - Totals const& _totals, - bool _aborting ) - : groupInfo( _groupInfo ), - totals( _totals ), - aborting( _aborting ) - {} - TestGroupStats( GroupInfo const& _groupInfo ) - : groupInfo( _groupInfo ), - aborting( false ) - {} - virtual ~TestGroupStats(); - -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - TestGroupStats( TestGroupStats const& ) = default; - TestGroupStats( TestGroupStats && ) = default; - TestGroupStats& operator = ( TestGroupStats const& ) = default; - TestGroupStats& operator = ( TestGroupStats && ) = default; -# endif - - GroupInfo groupInfo; - Totals totals; - bool aborting; - }; - - struct TestRunStats { - TestRunStats( TestRunInfo const& _runInfo, - Totals const& _totals, - bool _aborting ) - : runInfo( _runInfo ), - totals( _totals ), - aborting( _aborting ) - {} - virtual ~TestRunStats(); - -# ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS - TestRunStats( TestRunStats const& _other ) - : runInfo( _other.runInfo ), - totals( _other.totals ), - aborting( _other.aborting ) - {} -# else - TestRunStats( TestRunStats const& ) = default; - TestRunStats( TestRunStats && ) = default; - TestRunStats& operator = ( TestRunStats const& ) = default; - TestRunStats& operator = ( TestRunStats && ) = default; -# endif - - TestRunInfo runInfo; - Totals totals; - bool aborting; - }; - - struct IStreamingReporter : IShared { - virtual ~IStreamingReporter(); - - // Implementing class must also provide the following static method: - // static std::string getDescription(); - - virtual ReporterPreferences getPreferences() const = 0; - - virtual void noMatchingTestCases( std::string const& spec ) = 0; - - virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0; - virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0; - - virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0; - virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0; - - virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0; - - // The return value indicates if the messages buffer should be cleared: - virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0; - virtual void sectionEnded( SectionStats const& sectionStats ) = 0; - virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0; - virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0; - virtual void testRunEnded( TestRunStats const& testRunStats ) = 0; - - virtual void skipTest( TestCaseInfo const& testInfo ) = 0; - }; - - struct IReporterFactory { - virtual ~IReporterFactory(); - virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0; - virtual std::string getDescription() const = 0; - }; - - struct IReporterRegistry { - typedef std::map FactoryMap; - - virtual ~IReporterRegistry(); - virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0; - virtual FactoryMap const& getFactories() const = 0; - }; - -} - -#include -#include - -namespace Catch { - - inline std::size_t listTests( Config const& config ) { - - TestSpec testSpec = config.testSpec(); - if( config.testSpec().hasFilters() ) - Catch::cout() << "Matching test cases:\n"; - else { - Catch::cout() << "All available test cases:\n"; - testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); - } - - std::size_t matchedTests = 0; - TextAttributes nameAttr, tagsAttr; - nameAttr.setInitialIndent( 2 ).setIndent( 4 ); - tagsAttr.setIndent( 6 ); - - std::vector matchedTestCases; - getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases ); - for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); - it != itEnd; - ++it ) { - matchedTests++; - TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); - Colour::Code colour = testCaseInfo.isHidden() - ? Colour::SecondaryText - : Colour::None; - Colour colourGuard( colour ); - - Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl; - if( !testCaseInfo.tags.empty() ) - Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl; - } - - if( !config.testSpec().hasFilters() ) - Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl; - else - Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl; - return matchedTests; - } - - inline std::size_t listTestsNamesOnly( Config const& config ) { - TestSpec testSpec = config.testSpec(); - if( !config.testSpec().hasFilters() ) - testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); - std::size_t matchedTests = 0; - std::vector matchedTestCases; - getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases ); - for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); - it != itEnd; - ++it ) { - matchedTests++; - TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); - Catch::cout() << testCaseInfo.name << std::endl; - } - return matchedTests; - } - - struct TagInfo { - TagInfo() : count ( 0 ) {} - void add( std::string const& spelling ) { - ++count; - spellings.insert( spelling ); - } - std::string all() const { - std::string out; - for( std::set::const_iterator it = spellings.begin(), itEnd = spellings.end(); - it != itEnd; - ++it ) - out += "[" + *it + "]"; - return out; - } - std::set spellings; - std::size_t count; - }; - - inline std::size_t listTags( Config const& config ) { - TestSpec testSpec = config.testSpec(); - if( config.testSpec().hasFilters() ) - Catch::cout() << "Tags for matching test cases:\n"; - else { - Catch::cout() << "All available tags:\n"; - testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); - } - - std::map tagCounts; - - std::vector matchedTestCases; - getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases ); - for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); - it != itEnd; - ++it ) { - for( std::set::const_iterator tagIt = it->getTestCaseInfo().tags.begin(), - tagItEnd = it->getTestCaseInfo().tags.end(); - tagIt != tagItEnd; - ++tagIt ) { - std::string tagName = *tagIt; - std::string lcaseTagName = toLower( tagName ); - std::map::iterator countIt = tagCounts.find( lcaseTagName ); - if( countIt == tagCounts.end() ) - countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first; - countIt->second.add( tagName ); - } - } - - for( std::map::const_iterator countIt = tagCounts.begin(), - countItEnd = tagCounts.end(); - countIt != countItEnd; - ++countIt ) { - std::ostringstream oss; - oss << " " << std::setw(2) << countIt->second.count << " "; - Text wrapper( countIt->second.all(), TextAttributes() - .setInitialIndent( 0 ) - .setIndent( oss.str().size() ) - .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) ); - Catch::cout() << oss.str() << wrapper << "\n"; - } - Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl; - return tagCounts.size(); - } - - inline std::size_t listReporters( Config const& /*config*/ ) { - Catch::cout() << "Available reporters:\n"; - IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories(); - IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it; - std::size_t maxNameLen = 0; - for(it = itBegin; it != itEnd; ++it ) - maxNameLen = (std::max)( maxNameLen, it->first.size() ); - - for(it = itBegin; it != itEnd; ++it ) { - Text wrapper( it->second->getDescription(), TextAttributes() - .setInitialIndent( 0 ) - .setIndent( 7+maxNameLen ) - .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) ); - Catch::cout() << " " - << it->first - << ":" - << std::string( maxNameLen - it->first.size() + 2, ' ' ) - << wrapper << "\n"; - } - Catch::cout() << std::endl; - return factories.size(); - } - - inline Option list( Config const& config ) { - Option listedCount; - if( config.listTests() ) - listedCount = listedCount.valueOr(0) + listTests( config ); - if( config.listTestNamesOnly() ) - listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config ); - if( config.listTags() ) - listedCount = listedCount.valueOr(0) + listTags( config ); - if( config.listReporters() ) - listedCount = listedCount.valueOr(0) + listReporters( config ); - return listedCount; - } - -} // end namespace Catch - -// #included from: internal/catch_runner_impl.hpp -#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED - -// #included from: catch_test_case_tracker.hpp -#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED - -#include -#include -#include - -namespace Catch { -namespace SectionTracking { - - class TrackedSection { - - typedef std::map TrackedSections; - - public: - enum RunState { - NotStarted, - Executing, - ExecutingChildren, - Completed - }; - - TrackedSection( std::string const& name, TrackedSection* parent ) - : m_name( name ), m_runState( NotStarted ), m_parent( parent ) - {} - - RunState runState() const { return m_runState; } - - TrackedSection* findChild( std::string const& childName ) { - TrackedSections::iterator it = m_children.find( childName ); - return it != m_children.end() - ? &it->second - : NULL; - } - TrackedSection* acquireChild( std::string const& childName ) { - if( TrackedSection* child = findChild( childName ) ) - return child; - m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) ); - return findChild( childName ); - } - void enter() { - if( m_runState == NotStarted ) - m_runState = Executing; - } - void leave() { - for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end(); - it != itEnd; - ++it ) - if( it->second.runState() != Completed ) { - m_runState = ExecutingChildren; - return; - } - m_runState = Completed; - } - TrackedSection* getParent() { - return m_parent; - } - bool hasChildren() const { - return !m_children.empty(); - } - - private: - std::string m_name; - RunState m_runState; - TrackedSections m_children; - TrackedSection* m_parent; - - }; - - class TestCaseTracker { - public: - TestCaseTracker( std::string const& testCaseName ) - : m_testCase( testCaseName, NULL ), - m_currentSection( &m_testCase ), - m_completedASectionThisRun( false ) - {} - - bool enterSection( std::string const& name ) { - TrackedSection* child = m_currentSection->acquireChild( name ); - if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed ) - return false; - - m_currentSection = child; - m_currentSection->enter(); - return true; - } - void leaveSection() { - m_currentSection->leave(); - m_currentSection = m_currentSection->getParent(); - assert( m_currentSection != NULL ); - m_completedASectionThisRun = true; - } - - bool currentSectionHasChildren() const { - return m_currentSection->hasChildren(); - } - bool isCompleted() const { - return m_testCase.runState() == TrackedSection::Completed; - } - - class Guard { - public: - Guard( TestCaseTracker& tracker ) : m_tracker( tracker ) { - m_tracker.enterTestCase(); - } - ~Guard() { - m_tracker.leaveTestCase(); - } - private: - Guard( Guard const& ); - void operator = ( Guard const& ); - TestCaseTracker& m_tracker; - }; - - private: - void enterTestCase() { - m_currentSection = &m_testCase; - m_completedASectionThisRun = false; - m_testCase.enter(); - } - void leaveTestCase() { - m_testCase.leave(); - } - - TrackedSection m_testCase; - TrackedSection* m_currentSection; - bool m_completedASectionThisRun; - }; - -} // namespace SectionTracking - -using SectionTracking::TestCaseTracker; - -} // namespace Catch - -// #included from: catch_fatal_condition.hpp -#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED - -namespace Catch { - - // Report the error condition then exit the process - inline void fatal( std::string const& message, int exitCode ) { - IContext& context = Catch::getCurrentContext(); - IResultCapture* resultCapture = context.getResultCapture(); - resultCapture->handleFatalErrorCondition( message ); - - if( Catch::alwaysTrue() ) // avoids "no return" warnings - exit( exitCode ); - } - -} // namespace Catch - -#if defined ( CATCH_PLATFORM_WINDOWS ) ///////////////////////////////////////// - -namespace Catch { - - struct FatalConditionHandler { - void reset() {} - }; - -} // namespace Catch - -#else // Not Windows - assumed to be POSIX compatible ////////////////////////// - -#include - -namespace Catch { - - struct SignalDefs { int id; const char* name; }; - extern SignalDefs signalDefs[]; - SignalDefs signalDefs[] = { - { SIGINT, "SIGINT - Terminal interrupt signal" }, - { SIGILL, "SIGILL - Illegal instruction signal" }, - { SIGFPE, "SIGFPE - Floating point error signal" }, - { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, - { SIGTERM, "SIGTERM - Termination request signal" }, - { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } - }; - - struct FatalConditionHandler { - - static void handleSignal( int sig ) { - for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) - if( sig == signalDefs[i].id ) - fatal( signalDefs[i].name, -sig ); - fatal( "", -sig ); - } - - FatalConditionHandler() : m_isSet( true ) { - for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) - signal( signalDefs[i].id, handleSignal ); - } - ~FatalConditionHandler() { - reset(); - } - void reset() { - if( m_isSet ) { - for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) - signal( signalDefs[i].id, SIG_DFL ); - m_isSet = false; - } - } - - bool m_isSet; - }; - -} // namespace Catch - -#endif // not Windows - -#include -#include - -namespace Catch { - - class StreamRedirect { - - public: - StreamRedirect( std::ostream& stream, std::string& targetString ) - : m_stream( stream ), - m_prevBuf( stream.rdbuf() ), - m_targetString( targetString ) - { - stream.rdbuf( m_oss.rdbuf() ); - } - - ~StreamRedirect() { - m_targetString += m_oss.str(); - m_stream.rdbuf( m_prevBuf ); - } - - private: - std::ostream& m_stream; - std::streambuf* m_prevBuf; - std::ostringstream m_oss; - std::string& m_targetString; - }; - - /////////////////////////////////////////////////////////////////////////// - - class RunContext : public IResultCapture, public IRunner { - - RunContext( RunContext const& ); - void operator =( RunContext const& ); - - public: - - explicit RunContext( Ptr const& config, Ptr const& reporter ) - : m_runInfo( config->name() ), - m_context( getCurrentMutableContext() ), - m_activeTestCase( NULL ), - m_config( config ), - m_reporter( reporter ), - m_prevRunner( m_context.getRunner() ), - m_prevResultCapture( m_context.getResultCapture() ), - m_prevConfig( m_context.getConfig() ) - { - m_context.setRunner( this ); - m_context.setConfig( m_config ); - m_context.setResultCapture( this ); - m_reporter->testRunStarting( m_runInfo ); - } - - virtual ~RunContext() { - m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) ); - m_context.setRunner( m_prevRunner ); - m_context.setConfig( NULL ); - m_context.setResultCapture( m_prevResultCapture ); - m_context.setConfig( m_prevConfig ); - } - - void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { - m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) ); - } - void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) { - m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) ); - } - - Totals runTest( TestCase const& testCase ) { - Totals prevTotals = m_totals; - - std::string redirectedCout; - std::string redirectedCerr; - - TestCaseInfo testInfo = testCase.getTestCaseInfo(); - - m_reporter->testCaseStarting( testInfo ); - - m_activeTestCase = &testCase; - m_testCaseTracker = TestCaseTracker( testInfo.name ); - - do { - do { - runCurrentTest( redirectedCout, redirectedCerr ); - } - while( !m_testCaseTracker->isCompleted() && !aborting() ); - } - while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() ); - - Totals deltaTotals = m_totals.delta( prevTotals ); - m_totals.testCases += deltaTotals.testCases; - m_reporter->testCaseEnded( TestCaseStats( testInfo, - deltaTotals, - redirectedCout, - redirectedCerr, - aborting() ) ); - - m_activeTestCase = NULL; - m_testCaseTracker.reset(); - - return deltaTotals; - } - - Ptr config() const { - return m_config; - } - - private: // IResultCapture - - virtual void assertionEnded( AssertionResult const& result ) { - if( result.getResultType() == ResultWas::Ok ) { - m_totals.assertions.passed++; - } - else if( !result.isOk() ) { - m_totals.assertions.failed++; - } - - if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) ) - m_messages.clear(); - - // Reset working state - m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition ); - m_lastResult = result; - } - - virtual bool sectionStarted ( - SectionInfo const& sectionInfo, - Counts& assertions - ) - { - std::ostringstream oss; - oss << sectionInfo.name << "@" << sectionInfo.lineInfo; - - if( !m_testCaseTracker->enterSection( oss.str() ) ) - return false; - - m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; - - m_reporter->sectionStarting( sectionInfo ); - - assertions = m_totals.assertions; - - return true; - } - bool testForMissingAssertions( Counts& assertions ) { - if( assertions.total() != 0 || - !m_config->warnAboutMissingAssertions() || - m_testCaseTracker->currentSectionHasChildren() ) - return false; - m_totals.assertions.failed++; - assertions.failed++; - return true; - } - - virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) { - if( std::uncaught_exception() ) { - m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) ); - return; - } - - Counts assertions = m_totals.assertions - prevAssertions; - bool missingAssertions = testForMissingAssertions( assertions ); - - m_testCaseTracker->leaveSection(); - - m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) ); - m_messages.clear(); - } - - virtual void pushScopedMessage( MessageInfo const& message ) { - m_messages.push_back( message ); - } - - virtual void popScopedMessage( MessageInfo const& message ) { - m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() ); - } - - virtual std::string getCurrentTestName() const { - return m_activeTestCase - ? m_activeTestCase->getTestCaseInfo().name - : ""; - } - - virtual const AssertionResult* getLastResult() const { - return &m_lastResult; - } - - virtual void handleFatalErrorCondition( std::string const& message ) { - ResultBuilder resultBuilder = makeUnexpectedResultBuilder(); - resultBuilder.setResultType( ResultWas::FatalErrorCondition ); - resultBuilder << message; - resultBuilder.captureExpression(); - - handleUnfinishedSections(); - - // Recreate section for test case (as we will lose the one that was in scope) - TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); - SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); - - Counts assertions; - assertions.failed = 1; - SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false ); - m_reporter->sectionEnded( testCaseSectionStats ); - - TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo(); - - Totals deltaTotals; - deltaTotals.testCases.failed = 1; - m_reporter->testCaseEnded( TestCaseStats( testInfo, - deltaTotals, - "", - "", - false ) ); - m_totals.testCases.failed++; - testGroupEnded( "", m_totals, 1, 1 ); - m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) ); - } - - public: - // !TBD We need to do this another way! - bool aborting() const { - return m_totals.assertions.failed == static_cast( m_config->abortAfter() ); - } - - private: - - void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) { - TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); - SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); - m_reporter->sectionStarting( testCaseSection ); - Counts prevAssertions = m_totals.assertions; - double duration = 0; - try { - m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal ); - TestCaseTracker::Guard guard( *m_testCaseTracker ); - - Timer timer; - timer.start(); - if( m_reporter->getPreferences().shouldRedirectStdOut ) { - StreamRedirect coutRedir( Catch::cout(), redirectedCout ); - StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr ); - invokeActiveTestCase(); - } - else { - invokeActiveTestCase(); - } - duration = timer.getElapsedSeconds(); - } - catch( TestFailureException& ) { - // This just means the test was aborted due to failure - } - catch(...) { - makeUnexpectedResultBuilder().useActiveException(); - } - handleUnfinishedSections(); - m_messages.clear(); - - Counts assertions = m_totals.assertions - prevAssertions; - bool missingAssertions = testForMissingAssertions( assertions ); - - if( testCaseInfo.okToFail() ) { - std::swap( assertions.failedButOk, assertions.failed ); - m_totals.assertions.failed -= assertions.failedButOk; - m_totals.assertions.failedButOk += assertions.failedButOk; - } - - SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions ); - m_reporter->sectionEnded( testCaseSectionStats ); - } - - void invokeActiveTestCase() { - FatalConditionHandler fatalConditionHandler; // Handle signals - m_activeTestCase->invoke(); - fatalConditionHandler.reset(); - } - - private: - - ResultBuilder makeUnexpectedResultBuilder() const { - return ResultBuilder( m_lastAssertionInfo.macroName.c_str(), - m_lastAssertionInfo.lineInfo, - m_lastAssertionInfo.capturedExpression.c_str(), - m_lastAssertionInfo.resultDisposition ); - } - - void handleUnfinishedSections() { - // If sections ended prematurely due to an exception we stored their - // infos here so we can tear them down outside the unwind process. - for( std::vector::const_reverse_iterator it = m_unfinishedSections.rbegin(), - itEnd = m_unfinishedSections.rend(); - it != itEnd; - ++it ) - sectionEnded( it->info, it->prevAssertions, it->durationInSeconds ); - m_unfinishedSections.clear(); - } - - struct UnfinishedSections { - UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds ) - : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds ) - {} - - SectionInfo info; - Counts prevAssertions; - double durationInSeconds; - }; - - TestRunInfo m_runInfo; - IMutableContext& m_context; - TestCase const* m_activeTestCase; - Option m_testCaseTracker; - AssertionResult m_lastResult; - - Ptr m_config; - Totals m_totals; - Ptr m_reporter; - std::vector m_messages; - IRunner* m_prevRunner; - IResultCapture* m_prevResultCapture; - Ptr m_prevConfig; - AssertionInfo m_lastAssertionInfo; - std::vector m_unfinishedSections; - }; - - IResultCapture& getResultCapture() { - if( IResultCapture* capture = getCurrentContext().getResultCapture() ) - return *capture; - else - throw std::logic_error( "No result capture instance" ); - } - -} // end namespace Catch - -// #included from: internal/catch_version.h -#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED - -namespace Catch { - - // Versioning information - struct Version { - Version( unsigned int _majorVersion, - unsigned int _minorVersion, - unsigned int _buildNumber, - char const* const _branchName ) - : majorVersion( _majorVersion ), - minorVersion( _minorVersion ), - buildNumber( _buildNumber ), - branchName( _branchName ) - {} - - unsigned int const majorVersion; - unsigned int const minorVersion; - unsigned int const buildNumber; - char const* const branchName; - - private: - void operator=( Version const& ); - }; - - extern Version libraryVersion; -} - -#include -#include -#include - -namespace Catch { - - class Runner { - - public: - Runner( Ptr const& config ) - : m_config( config ) - { - openStream(); - makeReporter(); - } - - Totals runTests() { - - RunContext context( m_config.get(), m_reporter ); - - Totals totals; - - context.testGroupStarting( "all tests", 1, 1 ); // deprecated? - - TestSpec testSpec = m_config->testSpec(); - if( !testSpec.hasFilters() ) - testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests - - std::vector testCases; - getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, testCases ); - - int testsRunForGroup = 0; - for( std::vector::const_iterator it = testCases.begin(), itEnd = testCases.end(); - it != itEnd; - ++it ) { - testsRunForGroup++; - if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) { - - if( context.aborting() ) - break; - - totals += context.runTest( *it ); - m_testsAlreadyRun.insert( *it ); - } - } - std::vector skippedTestCases; - getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, skippedTestCases, true ); - - for( std::vector::const_iterator it = skippedTestCases.begin(), itEnd = skippedTestCases.end(); - it != itEnd; - ++it ) - m_reporter->skipTest( *it ); - - context.testGroupEnded( "all tests", totals, 1, 1 ); - return totals; - } - - private: - void openStream() { - // Open output file, if specified - if( !m_config->getFilename().empty() ) { - m_ofs.open( m_config->getFilename().c_str() ); - if( m_ofs.fail() ) { - std::ostringstream oss; - oss << "Unable to open file: '" << m_config->getFilename() << "'"; - throw std::domain_error( oss.str() ); - } - m_config->setStreamBuf( m_ofs.rdbuf() ); - } - } - void makeReporter() { - std::string reporterName = m_config->getReporterName().empty() - ? "console" - : m_config->getReporterName(); - - m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() ); - if( !m_reporter ) { - std::ostringstream oss; - oss << "No reporter registered with name: '" << reporterName << "'"; - throw std::domain_error( oss.str() ); - } - } - - private: - Ptr m_config; - std::ofstream m_ofs; - Ptr m_reporter; - std::set m_testsAlreadyRun; - }; - - class Session : NonCopyable { - static bool alreadyInstantiated; - - public: - - struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; }; - - Session() - : m_cli( makeCommandLineParser() ) { - if( alreadyInstantiated ) { - std::string msg = "Only one instance of Catch::Session can ever be used"; - Catch::cerr() << msg << std::endl; - throw std::logic_error( msg ); - } - alreadyInstantiated = true; - } - ~Session() { - Catch::cleanUp(); - } - - void showHelp( std::string const& processName ) { - Catch::cout() << "\nCatch v" << libraryVersion.majorVersion << "." - << libraryVersion.minorVersion << " build " - << libraryVersion.buildNumber; - if( libraryVersion.branchName != std::string( "master" ) ) - Catch::cout() << " (" << libraryVersion.branchName << " branch)"; - Catch::cout() << "\n"; - - m_cli.usage( Catch::cout(), processName ); - Catch::cout() << "For more detail usage please see the project docs\n" << std::endl; - } - - int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) { - try { - m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail ); - m_unusedTokens = m_cli.parseInto( argc, argv, m_configData ); - if( m_configData.showHelp ) - showHelp( m_configData.processName ); - m_config.reset(); - } - catch( std::exception& ex ) { - { - Colour colourGuard( Colour::Red ); - Catch::cerr() << "\nError(s) in input:\n" - << Text( ex.what(), TextAttributes().setIndent(2) ) - << "\n\n"; - } - m_cli.usage( Catch::cout(), m_configData.processName ); - return (std::numeric_limits::max)(); - } - return 0; - } - - void useConfigData( ConfigData const& _configData ) { - m_configData = _configData; - m_config.reset(); - } - - int run( int argc, char* const argv[] ) { - - int returnCode = applyCommandLine( argc, argv ); - if( returnCode == 0 ) - returnCode = run(); - return returnCode; - } - - int run() { - if( m_configData.showHelp ) - return 0; - - try - { - config(); // Force config to be constructed - - std::srand( m_configData.rngSeed ); - - Runner runner( m_config ); - - // Handle list request - if( Option listed = list( config() ) ) - return static_cast( *listed ); - - return static_cast( runner.runTests().assertions.failed ); - } - catch( std::exception& ex ) { - Catch::cerr() << ex.what() << std::endl; - return (std::numeric_limits::max)(); - } - } - - Clara::CommandLine const& cli() const { - return m_cli; - } - std::vector const& unusedTokens() const { - return m_unusedTokens; - } - ConfigData& configData() { - return m_configData; - } - Config& config() { - if( !m_config ) - m_config = new Config( m_configData ); - return *m_config; - } - - private: - Clara::CommandLine m_cli; - std::vector m_unusedTokens; - ConfigData m_configData; - Ptr m_config; - }; - - bool Session::alreadyInstantiated = false; - -} // end namespace Catch - -// #included from: catch_registry_hub.hpp -#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED - -// #included from: catch_test_case_registry_impl.hpp -#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED - -#include -#include -#include -#include -#include - -namespace Catch { - - class TestRegistry : public ITestCaseRegistry { - struct LexSort { - bool operator() (TestCase i,TestCase j) const { return (i const& getAllTests() const { - return m_functionsInOrder; - } - - virtual std::vector const& getAllNonHiddenTests() const { - return m_nonHiddenFunctions; - } - - virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector& matchingTestCases, bool negated = false ) const { - - for( std::vector::const_iterator it = m_functionsInOrder.begin(), - itEnd = m_functionsInOrder.end(); - it != itEnd; - ++it ) { - bool includeTest = testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() ); - if( includeTest != negated ) - matchingTestCases.push_back( *it ); - } - sortTests( config, matchingTestCases ); - } - - private: - - static void sortTests( IConfig const& config, std::vector& matchingTestCases ) { - - switch( config.runOrder() ) { - case RunTests::InLexicographicalOrder: - std::sort( matchingTestCases.begin(), matchingTestCases.end(), LexSort() ); - break; - case RunTests::InRandomOrder: - { - RandomNumberGenerator rng; - std::random_shuffle( matchingTestCases.begin(), matchingTestCases.end(), rng ); - } - break; - case RunTests::InDeclarationOrder: - // already in declaration order - break; - } - } - std::set m_functions; - std::vector m_functionsInOrder; - std::vector m_nonHiddenFunctions; - size_t m_unnamedCount; - }; - - /////////////////////////////////////////////////////////////////////////// - - class FreeFunctionTestCase : public SharedImpl { - public: - - FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {} - - virtual void invoke() const { - m_fun(); - } - - private: - virtual ~FreeFunctionTestCase(); - - TestFunction m_fun; - }; - - inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) { - std::string className = classOrQualifiedMethodName; - if( startsWith( className, "&" ) ) - { - std::size_t lastColons = className.rfind( "::" ); - std::size_t penultimateColons = className.rfind( "::", lastColons-1 ); - if( penultimateColons == std::string::npos ) - penultimateColons = 1; - className = className.substr( penultimateColons, lastColons-penultimateColons ); - } - return className; - } - - /////////////////////////////////////////////////////////////////////////// - - AutoReg::AutoReg( TestFunction function, - SourceLineInfo const& lineInfo, - NameAndDesc const& nameAndDesc ) { - registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo ); - } - - AutoReg::~AutoReg() {} - - void AutoReg::registerTestCase( ITestCase* testCase, - char const* classOrQualifiedMethodName, - NameAndDesc const& nameAndDesc, - SourceLineInfo const& lineInfo ) { - - getMutableRegistryHub().registerTest - ( makeTestCase( testCase, - extractClassName( classOrQualifiedMethodName ), - nameAndDesc.name, - nameAndDesc.description, - lineInfo ) ); - } - -} // end namespace Catch - -// #included from: catch_reporter_registry.hpp -#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED - -#include - -namespace Catch { - - class ReporterRegistry : public IReporterRegistry { - - public: - - virtual ~ReporterRegistry() { - deleteAllValues( m_factories ); - } - - virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const { - FactoryMap::const_iterator it = m_factories.find( name ); - if( it == m_factories.end() ) - return NULL; - return it->second->create( ReporterConfig( config ) ); - } - - void registerReporter( std::string const& name, IReporterFactory* factory ) { - m_factories.insert( std::make_pair( name, factory ) ); - } - - FactoryMap const& getFactories() const { - return m_factories; - } - - private: - FactoryMap m_factories; - }; -} - -// #included from: catch_exception_translator_registry.hpp -#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED - -#ifdef __OBJC__ -#import "Foundation/Foundation.h" -#endif - -namespace Catch { - - class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry { - public: - ~ExceptionTranslatorRegistry() { - deleteAll( m_translators ); - } - - virtual void registerTranslator( const IExceptionTranslator* translator ) { - m_translators.push_back( translator ); - } - - virtual std::string translateActiveException() const { - try { -#ifdef __OBJC__ - // In Objective-C try objective-c exceptions first - @try { - throw; - } - @catch (NSException *exception) { - return Catch::toString( [exception description] ); - } -#else - throw; -#endif - } - catch( TestFailureException& ) { - throw; - } - catch( std::exception& ex ) { - return ex.what(); - } - catch( std::string& msg ) { - return msg; - } - catch( const char* msg ) { - return msg; - } - catch(...) { - return tryTranslators( m_translators.begin() ); - } - } - - std::string tryTranslators( std::vector::const_iterator it ) const { - if( it == m_translators.end() ) - return "Unknown exception"; - - try { - return (*it)->translate(); - } - catch(...) { - return tryTranslators( it+1 ); - } - } - - private: - std::vector m_translators; - }; -} - -namespace Catch { - - namespace { - - class RegistryHub : public IRegistryHub, public IMutableRegistryHub { - - RegistryHub( RegistryHub const& ); - void operator=( RegistryHub const& ); - - public: // IRegistryHub - RegistryHub() { - } - virtual IReporterRegistry const& getReporterRegistry() const { - return m_reporterRegistry; - } - virtual ITestCaseRegistry const& getTestCaseRegistry() const { - return m_testCaseRegistry; - } - virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() { - return m_exceptionTranslatorRegistry; - } - - public: // IMutableRegistryHub - virtual void registerReporter( std::string const& name, IReporterFactory* factory ) { - m_reporterRegistry.registerReporter( name, factory ); - } - virtual void registerTest( TestCase const& testInfo ) { - m_testCaseRegistry.registerTest( testInfo ); - } - virtual void registerTranslator( const IExceptionTranslator* translator ) { - m_exceptionTranslatorRegistry.registerTranslator( translator ); - } - - private: - TestRegistry m_testCaseRegistry; - ReporterRegistry m_reporterRegistry; - ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; - }; - - // Single, global, instance - inline RegistryHub*& getTheRegistryHub() { - static RegistryHub* theRegistryHub = NULL; - if( !theRegistryHub ) - theRegistryHub = new RegistryHub(); - return theRegistryHub; - } - } - - IRegistryHub& getRegistryHub() { - return *getTheRegistryHub(); - } - IMutableRegistryHub& getMutableRegistryHub() { - return *getTheRegistryHub(); - } - void cleanUp() { - delete getTheRegistryHub(); - getTheRegistryHub() = NULL; - cleanUpContext(); - } - std::string translateActiveException() { - return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); - } - -} // end namespace Catch - -// #included from: catch_notimplemented_exception.hpp -#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED - -#include - -namespace Catch { - - NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) - : m_lineInfo( lineInfo ) { - std::ostringstream oss; - oss << lineInfo << ": function "; - oss << "not implemented"; - m_what = oss.str(); - } - - const char* NotImplementedException::what() const CATCH_NOEXCEPT { - return m_what.c_str(); - } - -} // end namespace Catch - -// #included from: catch_context_impl.hpp -#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED - -// #included from: catch_stream.hpp -#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED - -// #included from: catch_streambuf.h -#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED - -#include - -namespace Catch { - - class StreamBufBase : public std::streambuf { - public: - virtual ~StreamBufBase() CATCH_NOEXCEPT; - }; -} - -#include -#include -#include - -namespace Catch { - - template - class StreamBufImpl : public StreamBufBase { - char data[bufferSize]; - WriterF m_writer; - - public: - StreamBufImpl() { - setp( data, data + sizeof(data) ); - } - - ~StreamBufImpl() CATCH_NOEXCEPT { - sync(); - } - - private: - int overflow( int c ) { - sync(); - - if( c != EOF ) { - if( pbase() == epptr() ) - m_writer( std::string( 1, static_cast( c ) ) ); - else - sputc( static_cast( c ) ); - } - return 0; - } - - int sync() { - if( pbase() != pptr() ) { - m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); - setp( pbase(), epptr() ); - } - return 0; - } - }; - - /////////////////////////////////////////////////////////////////////////// - - struct OutputDebugWriter { - - void operator()( std::string const&str ) { - writeToDebugConsole( str ); - } - }; - - Stream::Stream() - : streamBuf( NULL ), isOwned( false ) - {} - - Stream::Stream( std::streambuf* _streamBuf, bool _isOwned ) - : streamBuf( _streamBuf ), isOwned( _isOwned ) - {} - - void Stream::release() { - if( isOwned ) { - delete streamBuf; - streamBuf = NULL; - isOwned = false; - } - } - -#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement this functions - std::ostream& cout() { - return std::cout; - } - std::ostream& cerr() { - return std::cerr; - } -#endif -} - -namespace Catch { - - class Context : public IMutableContext { - - Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {} - Context( Context const& ); - void operator=( Context const& ); - - public: // IContext - virtual IResultCapture* getResultCapture() { - return m_resultCapture; - } - virtual IRunner* getRunner() { - return m_runner; - } - virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) { - return getGeneratorsForCurrentTest() - .getGeneratorInfo( fileInfo, totalSize ) - .getCurrentIndex(); - } - virtual bool advanceGeneratorsForCurrentTest() { - IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); - return generators && generators->moveNext(); - } - - virtual Ptr getConfig() const { - return m_config; - } - - public: // IMutableContext - virtual void setResultCapture( IResultCapture* resultCapture ) { - m_resultCapture = resultCapture; - } - virtual void setRunner( IRunner* runner ) { - m_runner = runner; - } - virtual void setConfig( Ptr const& config ) { - m_config = config; - } - - friend IMutableContext& getCurrentMutableContext(); - - private: - IGeneratorsForTest* findGeneratorsForCurrentTest() { - std::string testName = getResultCapture()->getCurrentTestName(); - - std::map::const_iterator it = - m_generatorsByTestName.find( testName ); - return it != m_generatorsByTestName.end() - ? it->second - : NULL; - } - - IGeneratorsForTest& getGeneratorsForCurrentTest() { - IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); - if( !generators ) { - std::string testName = getResultCapture()->getCurrentTestName(); - generators = createGeneratorsForTest(); - m_generatorsByTestName.insert( std::make_pair( testName, generators ) ); - } - return *generators; - } - - private: - Ptr m_config; - IRunner* m_runner; - IResultCapture* m_resultCapture; - std::map m_generatorsByTestName; - }; - - namespace { - Context* currentContext = NULL; - } - IMutableContext& getCurrentMutableContext() { - if( !currentContext ) - currentContext = new Context(); - return *currentContext; - } - IContext& getCurrentContext() { - return getCurrentMutableContext(); - } - - Stream createStream( std::string const& streamName ) { - if( streamName == "stdout" ) return Stream( Catch::cout().rdbuf(), false ); - if( streamName == "stderr" ) return Stream( Catch::cerr().rdbuf(), false ); - if( streamName == "debug" ) return Stream( new StreamBufImpl, true ); - - throw std::domain_error( "Unknown stream: " + streamName ); - } - - void cleanUpContext() { - delete currentContext; - currentContext = NULL; - } -} - -// #included from: catch_console_colour_impl.hpp -#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED - -namespace Catch { - namespace { - - struct IColourImpl { - virtual ~IColourImpl() {} - virtual void use( Colour::Code _colourCode ) = 0; - }; - - struct NoColourImpl : IColourImpl { - void use( Colour::Code ) {} - - static IColourImpl* instance() { - static NoColourImpl s_instance; - return &s_instance; - } - }; - - } // anon namespace -} // namespace Catch - -#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI ) -# ifdef CATCH_PLATFORM_WINDOWS -# define CATCH_CONFIG_COLOUR_WINDOWS -# else -# define CATCH_CONFIG_COLOUR_ANSI -# endif -#endif - -#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) ///////////////////////////////////////// - -#ifndef NOMINMAX -#define NOMINMAX -#endif - -#ifdef __AFXDLL -#include -#else -#include -#endif - -namespace Catch { -namespace { - - class Win32ColourImpl : public IColourImpl { - public: - Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) ) - { - CONSOLE_SCREEN_BUFFER_INFO csbiInfo; - GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo ); - originalAttributes = csbiInfo.wAttributes; - } - - virtual void use( Colour::Code _colourCode ) { - switch( _colourCode ) { - case Colour::None: return setTextAttribute( originalAttributes ); - case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); - case Colour::Red: return setTextAttribute( FOREGROUND_RED ); - case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); - case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); - case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); - case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); - case Colour::Grey: return setTextAttribute( 0 ); - - case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); - case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); - case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); - case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); - - case Colour::Bright: throw std::logic_error( "not a colour" ); - } - } - - private: - void setTextAttribute( WORD _textAttribute ) { - SetConsoleTextAttribute( stdoutHandle, _textAttribute ); - } - HANDLE stdoutHandle; - WORD originalAttributes; - }; - - IColourImpl* platformColourInstance() { - static Win32ColourImpl s_instance; - return &s_instance; - } - -} // end anon namespace -} // end namespace Catch - -#elif defined( CATCH_CONFIG_COLOUR_ANSI ) ////////////////////////////////////// - -#include - -namespace Catch { -namespace { - - // use POSIX/ ANSI console terminal codes - // Thanks to Adam Strzelecki for original contribution - // (http://github.com/nanoant) - // https://github.com/philsquared/Catch/pull/131 - class PosixColourImpl : public IColourImpl { - public: - virtual void use( Colour::Code _colourCode ) { - switch( _colourCode ) { - case Colour::None: - case Colour::White: return setColour( "[0m" ); - case Colour::Red: return setColour( "[0;31m" ); - case Colour::Green: return setColour( "[0;32m" ); - case Colour::Blue: return setColour( "[0:34m" ); - case Colour::Cyan: return setColour( "[0;36m" ); - case Colour::Yellow: return setColour( "[0;33m" ); - case Colour::Grey: return setColour( "[1;30m" ); - - case Colour::LightGrey: return setColour( "[0;37m" ); - case Colour::BrightRed: return setColour( "[1;31m" ); - case Colour::BrightGreen: return setColour( "[1;32m" ); - case Colour::BrightWhite: return setColour( "[1;37m" ); - - case Colour::Bright: throw std::logic_error( "not a colour" ); - } - } - static IColourImpl* instance() { - static PosixColourImpl s_instance; - return &s_instance; - } - - private: - void setColour( const char* _escapeCode ) { - Catch::cout() << '\033' << _escapeCode; - } - }; - - IColourImpl* platformColourInstance() { - Ptr config = getCurrentContext().getConfig(); - return (config && config->forceColour()) || isatty(STDOUT_FILENO) - ? PosixColourImpl::instance() - : NoColourImpl::instance(); - } - -} // end anon namespace -} // end namespace Catch - -#else // not Windows or ANSI /////////////////////////////////////////////// - -namespace Catch { - - static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); } - -} // end namespace Catch - -#endif // Windows/ ANSI/ None - -namespace Catch { - - Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); } - Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast( _other ).m_moved = true; } - Colour::~Colour(){ if( !m_moved ) use( None ); } - - void Colour::use( Code _colourCode ) { - static IColourImpl* impl = isDebuggerActive() - ? NoColourImpl::instance() - : platformColourInstance(); - impl->use( _colourCode ); - } - -} // end namespace Catch - -// #included from: catch_generators_impl.hpp -#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED - -#include -#include -#include - -namespace Catch { - - struct GeneratorInfo : IGeneratorInfo { - - GeneratorInfo( std::size_t size ) - : m_size( size ), - m_currentIndex( 0 ) - {} - - bool moveNext() { - if( ++m_currentIndex == m_size ) { - m_currentIndex = 0; - return false; - } - return true; - } - - std::size_t getCurrentIndex() const { - return m_currentIndex; - } - - std::size_t m_size; - std::size_t m_currentIndex; - }; - - /////////////////////////////////////////////////////////////////////////// - - class GeneratorsForTest : public IGeneratorsForTest { - - public: - ~GeneratorsForTest() { - deleteAll( m_generatorsInOrder ); - } - - IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) { - std::map::const_iterator it = m_generatorsByName.find( fileInfo ); - if( it == m_generatorsByName.end() ) { - IGeneratorInfo* info = new GeneratorInfo( size ); - m_generatorsByName.insert( std::make_pair( fileInfo, info ) ); - m_generatorsInOrder.push_back( info ); - return *info; - } - return *it->second; - } - - bool moveNext() { - std::vector::const_iterator it = m_generatorsInOrder.begin(); - std::vector::const_iterator itEnd = m_generatorsInOrder.end(); - for(; it != itEnd; ++it ) { - if( (*it)->moveNext() ) - return true; - } - return false; - } - - private: - std::map m_generatorsByName; - std::vector m_generatorsInOrder; - }; - - IGeneratorsForTest* createGeneratorsForTest() - { - return new GeneratorsForTest(); - } - -} // end namespace Catch - -// #included from: catch_assertionresult.hpp -#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED - -namespace Catch { - - AssertionInfo::AssertionInfo( std::string const& _macroName, - SourceLineInfo const& _lineInfo, - std::string const& _capturedExpression, - ResultDisposition::Flags _resultDisposition ) - : macroName( _macroName ), - lineInfo( _lineInfo ), - capturedExpression( _capturedExpression ), - resultDisposition( _resultDisposition ) - {} - - AssertionResult::AssertionResult() {} - - AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data ) - : m_info( info ), - m_resultData( data ) - {} - - AssertionResult::~AssertionResult() {} - - // Result was a success - bool AssertionResult::succeeded() const { - return Catch::isOk( m_resultData.resultType ); - } - - // Result was a success, or failure is suppressed - bool AssertionResult::isOk() const { - return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); - } - - ResultWas::OfType AssertionResult::getResultType() const { - return m_resultData.resultType; - } - - bool AssertionResult::hasExpression() const { - return !m_info.capturedExpression.empty(); - } - - bool AssertionResult::hasMessage() const { - return !m_resultData.message.empty(); - } - - std::string AssertionResult::getExpression() const { - if( isFalseTest( m_info.resultDisposition ) ) - return "!" + m_info.capturedExpression; - else - return m_info.capturedExpression; - } - std::string AssertionResult::getExpressionInMacro() const { - if( m_info.macroName.empty() ) - return m_info.capturedExpression; - else - return m_info.macroName + "( " + m_info.capturedExpression + " )"; - } - - bool AssertionResult::hasExpandedExpression() const { - return hasExpression() && getExpandedExpression() != getExpression(); - } - - std::string AssertionResult::getExpandedExpression() const { - return m_resultData.reconstructedExpression; - } - - std::string AssertionResult::getMessage() const { - return m_resultData.message; - } - SourceLineInfo AssertionResult::getSourceInfo() const { - return m_info.lineInfo; - } - - std::string AssertionResult::getTestMacroName() const { - return m_info.macroName; - } - -} // end namespace Catch - -// #included from: catch_test_case_info.hpp -#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED - -namespace Catch { - - inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) { - if( startsWith( tag, "." ) || - tag == "hide" || - tag == "!hide" ) - return TestCaseInfo::IsHidden; - else if( tag == "!throws" ) - return TestCaseInfo::Throws; - else if( tag == "!shouldfail" ) - return TestCaseInfo::ShouldFail; - else if( tag == "!mayfail" ) - return TestCaseInfo::MayFail; - else - return TestCaseInfo::None; - } - inline bool isReservedTag( std::string const& tag ) { - return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] ); - } - inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) { - if( isReservedTag( tag ) ) { - { - Colour colourGuard( Colour::Red ); - Catch::cerr() - << "Tag name [" << tag << "] not allowed.\n" - << "Tag names starting with non alpha-numeric characters are reserved\n"; - } - { - Colour colourGuard( Colour::FileName ); - Catch::cerr() << _lineInfo << std::endl; - } - exit(1); - } - } - - TestCase makeTestCase( ITestCase* _testCase, - std::string const& _className, - std::string const& _name, - std::string const& _descOrTags, - SourceLineInfo const& _lineInfo ) - { - bool isHidden( startsWith( _name, "./" ) ); // Legacy support - - // Parse out tags - std::set tags; - std::string desc, tag; - bool inTag = false; - for( std::size_t i = 0; i < _descOrTags.size(); ++i ) { - char c = _descOrTags[i]; - if( !inTag ) { - if( c == '[' ) - inTag = true; - else - desc += c; - } - else { - if( c == ']' ) { - TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag ); - if( prop == TestCaseInfo::IsHidden ) - isHidden = true; - else if( prop == TestCaseInfo::None ) - enforceNotReservedTag( tag, _lineInfo ); - - tags.insert( tag ); - tag.clear(); - inTag = false; - } - else - tag += c; - } - } - if( isHidden ) { - tags.insert( "hide" ); - tags.insert( "." ); - } - - TestCaseInfo info( _name, _className, desc, tags, _lineInfo ); - return TestCase( _testCase, info ); - } - - TestCaseInfo::TestCaseInfo( std::string const& _name, - std::string const& _className, - std::string const& _description, - std::set const& _tags, - SourceLineInfo const& _lineInfo ) - : name( _name ), - className( _className ), - description( _description ), - tags( _tags ), - lineInfo( _lineInfo ), - properties( None ) - { - std::ostringstream oss; - for( std::set::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) { - oss << "[" << *it << "]"; - std::string lcaseTag = toLower( *it ); - properties = static_cast( properties | parseSpecialTag( lcaseTag ) ); - lcaseTags.insert( lcaseTag ); - } - tagsAsString = oss.str(); - } - - TestCaseInfo::TestCaseInfo( TestCaseInfo const& other ) - : name( other.name ), - className( other.className ), - description( other.description ), - tags( other.tags ), - lcaseTags( other.lcaseTags ), - tagsAsString( other.tagsAsString ), - lineInfo( other.lineInfo ), - properties( other.properties ) - {} - - bool TestCaseInfo::isHidden() const { - return ( properties & IsHidden ) != 0; - } - bool TestCaseInfo::throws() const { - return ( properties & Throws ) != 0; - } - bool TestCaseInfo::okToFail() const { - return ( properties & (ShouldFail | MayFail ) ) != 0; - } - bool TestCaseInfo::expectedToFail() const { - return ( properties & (ShouldFail ) ) != 0; - } - - TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {} - - TestCase::TestCase( TestCase const& other ) - : TestCaseInfo( other ), - test( other.test ) - {} - - TestCase TestCase::withName( std::string const& _newName ) const { - TestCase other( *this ); - other.name = _newName; - return other; - } - - void TestCase::swap( TestCase& other ) { - test.swap( other.test ); - name.swap( other.name ); - className.swap( other.className ); - description.swap( other.description ); - tags.swap( other.tags ); - lcaseTags.swap( other.lcaseTags ); - tagsAsString.swap( other.tagsAsString ); - std::swap( TestCaseInfo::properties, static_cast( other ).properties ); - std::swap( lineInfo, other.lineInfo ); - } - - void TestCase::invoke() const { - test->invoke(); - } - - bool TestCase::operator == ( TestCase const& other ) const { - return test.get() == other.test.get() && - name == other.name && - className == other.className; - } - - bool TestCase::operator < ( TestCase const& other ) const { - return name < other.name; - } - TestCase& TestCase::operator = ( TestCase const& other ) { - TestCase temp( other ); - swap( temp ); - return *this; - } - - TestCaseInfo const& TestCase::getTestCaseInfo() const - { - return *this; - } - -} // end namespace Catch - -// #included from: catch_version.hpp -#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED - -namespace Catch { - - // These numbers are maintained by a script - Version libraryVersion( 1, 1, 3, "master" ); -} - -// #included from: catch_message.hpp -#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED - -namespace Catch { - - MessageInfo::MessageInfo( std::string const& _macroName, - SourceLineInfo const& _lineInfo, - ResultWas::OfType _type ) - : macroName( _macroName ), - lineInfo( _lineInfo ), - type( _type ), - sequence( ++globalCount ) - {} - - // This may need protecting if threading support is added - unsigned int MessageInfo::globalCount = 0; - - //////////////////////////////////////////////////////////////////////////// - - ScopedMessage::ScopedMessage( MessageBuilder const& builder ) - : m_info( builder.m_info ) - { - m_info.message = builder.m_stream.str(); - getResultCapture().pushScopedMessage( m_info ); - } - ScopedMessage::ScopedMessage( ScopedMessage const& other ) - : m_info( other.m_info ) - {} - - ScopedMessage::~ScopedMessage() { - getResultCapture().popScopedMessage( m_info ); - } - -} // end namespace Catch - -// #included from: catch_legacy_reporter_adapter.hpp -#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED - -// #included from: catch_legacy_reporter_adapter.h -#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED - -namespace Catch -{ - // Deprecated - struct IReporter : IShared { - virtual ~IReporter(); - - virtual bool shouldRedirectStdout() const = 0; - - virtual void StartTesting() = 0; - virtual void EndTesting( Totals const& totals ) = 0; - virtual void StartGroup( std::string const& groupName ) = 0; - virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0; - virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0; - virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0; - virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0; - virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0; - virtual void NoAssertionsInSection( std::string const& sectionName ) = 0; - virtual void NoAssertionsInTestCase( std::string const& testName ) = 0; - virtual void Aborted() = 0; - virtual void Result( AssertionResult const& result ) = 0; - }; - - class LegacyReporterAdapter : public SharedImpl - { - public: - LegacyReporterAdapter( Ptr const& legacyReporter ); - virtual ~LegacyReporterAdapter(); - - virtual ReporterPreferences getPreferences() const; - virtual void noMatchingTestCases( std::string const& ); - virtual void testRunStarting( TestRunInfo const& ); - virtual void testGroupStarting( GroupInfo const& groupInfo ); - virtual void testCaseStarting( TestCaseInfo const& testInfo ); - virtual void sectionStarting( SectionInfo const& sectionInfo ); - virtual void assertionStarting( AssertionInfo const& ); - virtual bool assertionEnded( AssertionStats const& assertionStats ); - virtual void sectionEnded( SectionStats const& sectionStats ); - virtual void testCaseEnded( TestCaseStats const& testCaseStats ); - virtual void testGroupEnded( TestGroupStats const& testGroupStats ); - virtual void testRunEnded( TestRunStats const& testRunStats ); - virtual void skipTest( TestCaseInfo const& ); - - private: - Ptr m_legacyReporter; - }; -} - -namespace Catch -{ - LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter ) - : m_legacyReporter( legacyReporter ) - {} - LegacyReporterAdapter::~LegacyReporterAdapter() {} - - ReporterPreferences LegacyReporterAdapter::getPreferences() const { - ReporterPreferences prefs; - prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout(); - return prefs; - } - - void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {} - void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) { - m_legacyReporter->StartTesting(); - } - void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) { - m_legacyReporter->StartGroup( groupInfo.name ); - } - void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) { - m_legacyReporter->StartTestCase( testInfo ); - } - void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) { - m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description ); - } - void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) { - // Not on legacy interface - } - - bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) { - if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { - for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); - it != itEnd; - ++it ) { - if( it->type == ResultWas::Info ) { - ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal ); - rb << it->message; - rb.setResultType( ResultWas::Info ); - AssertionResult result = rb.build(); - m_legacyReporter->Result( result ); - } - } - } - m_legacyReporter->Result( assertionStats.assertionResult ); - return true; - } - void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) { - if( sectionStats.missingAssertions ) - m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name ); - m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions ); - } - void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) { - m_legacyReporter->EndTestCase - ( testCaseStats.testInfo, - testCaseStats.totals, - testCaseStats.stdOut, - testCaseStats.stdErr ); - } - void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) { - if( testGroupStats.aborting ) - m_legacyReporter->Aborted(); - m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals ); - } - void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) { - m_legacyReporter->EndTesting( testRunStats.totals ); - } - void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) { - } -} - -// #included from: catch_timer.hpp - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wc++11-long-long" -#endif - -#ifdef CATCH_PLATFORM_WINDOWS -#include -#else -#include -#endif - -namespace Catch { - - namespace { -#ifdef CATCH_PLATFORM_WINDOWS - uint64_t getCurrentTicks() { - static uint64_t hz=0, hzo=0; - if (!hz) { - QueryPerformanceFrequency( reinterpret_cast( &hz ) ); - QueryPerformanceCounter( reinterpret_cast( &hzo ) ); - } - uint64_t t; - QueryPerformanceCounter( reinterpret_cast( &t ) ); - return ((t-hzo)*1000000)/hz; - } -#else - uint64_t getCurrentTicks() { - timeval t; - gettimeofday(&t,NULL); - return static_cast( t.tv_sec ) * 1000000ull + static_cast( t.tv_usec ); - } -#endif - } - - void Timer::start() { - m_ticks = getCurrentTicks(); - } - unsigned int Timer::getElapsedMicroseconds() const { - return static_cast(getCurrentTicks() - m_ticks); - } - unsigned int Timer::getElapsedMilliseconds() const { - return static_cast(getElapsedMicroseconds()/1000); - } - double Timer::getElapsedSeconds() const { - return getElapsedMicroseconds()/1000000.0; - } - -} // namespace Catch - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif -// #included from: catch_common.hpp -#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED - -namespace Catch { - - bool startsWith( std::string const& s, std::string const& prefix ) { - return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix; - } - bool endsWith( std::string const& s, std::string const& suffix ) { - return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix; - } - bool contains( std::string const& s, std::string const& infix ) { - return s.find( infix ) != std::string::npos; - } - void toLowerInPlace( std::string& s ) { - std::transform( s.begin(), s.end(), s.begin(), ::tolower ); - } - std::string toLower( std::string const& s ) { - std::string lc = s; - toLowerInPlace( lc ); - return lc; - } - std::string trim( std::string const& str ) { - static char const* whitespaceChars = "\n\r\t "; - std::string::size_type start = str.find_first_not_of( whitespaceChars ); - std::string::size_type end = str.find_last_not_of( whitespaceChars ); - - return start != std::string::npos ? str.substr( start, 1+end-start ) : ""; - } - - bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { - bool replaced = false; - std::size_t i = str.find( replaceThis ); - while( i != std::string::npos ) { - replaced = true; - str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() ); - if( i < str.size()-withThis.size() ) - i = str.find( replaceThis, i+withThis.size() ); - else - i = std::string::npos; - } - return replaced; - } - - pluralise::pluralise( std::size_t count, std::string const& label ) - : m_count( count ), - m_label( label ) - {} - - std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { - os << pluraliser.m_count << " " << pluraliser.m_label; - if( pluraliser.m_count != 1 ) - os << "s"; - return os; - } - - SourceLineInfo::SourceLineInfo() : line( 0 ){} - SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) - : file( _file ), - line( _line ) - {} - SourceLineInfo::SourceLineInfo( SourceLineInfo const& other ) - : file( other.file ), - line( other.line ) - {} - bool SourceLineInfo::empty() const { - return file.empty(); - } - bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const { - return line == other.line && file == other.file; - } - bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const { - return line < other.line || ( line == other.line && file < other.file ); - } - - std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { -#ifndef __GNUG__ - os << info.file << "(" << info.line << ")"; -#else - os << info.file << ":" << info.line; -#endif - return os; - } - - void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) { - std::ostringstream oss; - oss << locationInfo << ": Internal Catch error: '" << message << "'"; - if( alwaysTrue() ) - throw std::logic_error( oss.str() ); - } -} - -// #included from: catch_section.hpp -#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED - -namespace Catch { - - SectionInfo::SectionInfo - ( SourceLineInfo const& _lineInfo, - std::string const& _name, - std::string const& _description ) - : name( _name ), - description( _description ), - lineInfo( _lineInfo ) - {} - - Section::Section( SectionInfo const& info ) - : m_info( info ), - m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) ) - { - m_timer.start(); - } - - Section::~Section() { - if( m_sectionIncluded ) - getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() ); - } - - // This indicates whether the section should be executed or not - Section::operator bool() const { - return m_sectionIncluded; - } - -} // end namespace Catch - -// #included from: catch_debugger.hpp -#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED - -#include - -#ifdef CATCH_PLATFORM_MAC - - #include - #include - #include - #include - #include - - namespace Catch{ - - // The following function is taken directly from the following technical note: - // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html - - // Returns true if the current process is being debugged (either - // running under the debugger or has a debugger attached post facto). - bool isDebuggerActive(){ - - int mib[4]; - struct kinfo_proc info; - size_t size; - - // Initialize the flags so that, if sysctl fails for some bizarre - // reason, we get a predictable result. - - info.kp_proc.p_flag = 0; - - // Initialize mib, which tells sysctl the info we want, in this case - // we're looking for information about a specific process ID. - - mib[0] = CTL_KERN; - mib[1] = KERN_PROC; - mib[2] = KERN_PROC_PID; - mib[3] = getpid(); - - // Call sysctl. - - size = sizeof(info); - if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) { - Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl; - return false; - } - - // We're being debugged if the P_TRACED flag is set. - - return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); - } - } // namespace Catch - -#elif defined(_MSC_VER) - extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); - namespace Catch { - bool isDebuggerActive() { - return IsDebuggerPresent() != 0; - } - } -#elif defined(__MINGW32__) - extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); - namespace Catch { - bool isDebuggerActive() { - return IsDebuggerPresent() != 0; - } - } -#else - namespace Catch { - inline bool isDebuggerActive() { return false; } - } -#endif // Platform - -#ifdef CATCH_PLATFORM_WINDOWS - extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* ); - namespace Catch { - void writeToDebugConsole( std::string const& text ) { - ::OutputDebugStringA( text.c_str() ); - } - } -#else - namespace Catch { - void writeToDebugConsole( std::string const& text ) { - // !TBD: Need a version for Mac/ XCode and other IDEs - Catch::cout() << text; - } - } -#endif // Platform - -// #included from: catch_tostring.hpp -#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED - -namespace Catch { - -namespace Detail { - - std::string unprintableString = "{?}"; - - namespace { - struct Endianness { - enum Arch { Big, Little }; - - static Arch which() { - union _{ - int asInt; - char asChar[sizeof (int)]; - } u; - - u.asInt = 1; - return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little; - } - }; - } - - std::string rawMemoryToString( const void *object, std::size_t size ) - { - // Reverse order for little endian architectures - int i = 0, end = static_cast( size ), inc = 1; - if( Endianness::which() == Endianness::Little ) { - i = end-1; - end = inc = -1; - } - - unsigned char const *bytes = static_cast(object); - std::ostringstream os; - os << "0x" << std::setfill('0') << std::hex; - for( ; i != end; i += inc ) - os << std::setw(2) << static_cast(bytes[i]); - return os.str(); - } -} - -std::string toString( std::string const& value ) { - std::string s = value; - if( getCurrentContext().getConfig()->showInvisibles() ) { - for(size_t i = 0; i < s.size(); ++i ) { - std::string subs; - switch( s[i] ) { - case '\n': subs = "\\n"; break; - case '\t': subs = "\\t"; break; - default: break; - } - if( !subs.empty() ) { - s = s.substr( 0, i ) + subs + s.substr( i+1 ); - ++i; - } - } - } - return "\"" + s + "\""; -} -std::string toString( std::wstring const& value ) { - - std::string s; - s.reserve( value.size() ); - for(size_t i = 0; i < value.size(); ++i ) - s += value[i] <= 0xff ? static_cast( value[i] ) : '?'; - return Catch::toString( s ); -} - -std::string toString( const char* const value ) { - return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" ); -} - -std::string toString( char* const value ) { - return Catch::toString( static_cast( value ) ); -} - -std::string toString( const wchar_t* const value ) -{ - return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" ); -} - -std::string toString( wchar_t* const value ) -{ - return Catch::toString( static_cast( value ) ); -} - -std::string toString( int value ) { - std::ostringstream oss; - if( value > 8192 ) - oss << "0x" << std::hex << value; - else - oss << value; - return oss.str(); -} - -std::string toString( unsigned long value ) { - std::ostringstream oss; - if( value > 8192 ) - oss << "0x" << std::hex << value; - else - oss << value; - return oss.str(); -} - -std::string toString( unsigned int value ) { - return Catch::toString( static_cast( value ) ); -} - -template -std::string fpToString( T value, int precision ) { - std::ostringstream oss; - oss << std::setprecision( precision ) - << std::fixed - << value; - std::string d = oss.str(); - std::size_t i = d.find_last_not_of( '0' ); - if( i != std::string::npos && i != d.size()-1 ) { - if( d[i] == '.' ) - i++; - d = d.substr( 0, i+1 ); - } - return d; -} - -std::string toString( const double value ) { - return fpToString( value, 10 ); -} -std::string toString( const float value ) { - return fpToString( value, 5 ) + "f"; -} - -std::string toString( bool value ) { - return value ? "true" : "false"; -} - -std::string toString( char value ) { - return value < ' ' - ? toString( static_cast( value ) ) - : Detail::makeString( value ); -} - -std::string toString( signed char value ) { - return toString( static_cast( value ) ); -} - -std::string toString( unsigned char value ) { - return toString( static_cast( value ) ); -} - -#ifdef CATCH_CONFIG_CPP11_NULLPTR -std::string toString( std::nullptr_t ) { - return "nullptr"; -} -#endif - -#ifdef __OBJC__ - std::string toString( NSString const * const& nsstring ) { - if( !nsstring ) - return "nil"; - return "@" + toString([nsstring UTF8String]); - } - std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) { - if( !nsstring ) - return "nil"; - return "@" + toString([nsstring UTF8String]); - } - std::string toString( NSObject* const& nsObject ) { - return toString( [nsObject description] ); - } -#endif - -} // end namespace Catch - -// #included from: catch_result_builder.hpp -#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED - -namespace Catch { - - ResultBuilder::ResultBuilder( char const* macroName, - SourceLineInfo const& lineInfo, - char const* capturedExpression, - ResultDisposition::Flags resultDisposition ) - : m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition ), - m_shouldDebugBreak( false ), - m_shouldThrow( false ) - {} - - ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) { - m_data.resultType = result; - return *this; - } - ResultBuilder& ResultBuilder::setResultType( bool result ) { - m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; - return *this; - } - ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) { - m_exprComponents.lhs = lhs; - return *this; - } - ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) { - m_exprComponents.rhs = rhs; - return *this; - } - ResultBuilder& ResultBuilder::setOp( std::string const& op ) { - m_exprComponents.op = op; - return *this; - } - - void ResultBuilder::endExpression() { - m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition ); - captureExpression(); - } - - void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) { - m_assertionInfo.resultDisposition = resultDisposition; - m_stream.oss << Catch::translateActiveException(); - captureResult( ResultWas::ThrewException ); - } - - void ResultBuilder::captureResult( ResultWas::OfType resultType ) { - setResultType( resultType ); - captureExpression(); - } - - void ResultBuilder::captureExpression() { - AssertionResult result = build(); - getResultCapture().assertionEnded( result ); - - if( !result.isOk() ) { - if( getCurrentContext().getConfig()->shouldDebugBreak() ) - m_shouldDebugBreak = true; - if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) ) - m_shouldThrow = true; - } - } - void ResultBuilder::react() { - if( m_shouldThrow ) - throw Catch::TestFailureException(); - } - - bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; } - bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); } - - AssertionResult ResultBuilder::build() const - { - assert( m_data.resultType != ResultWas::Unknown ); - - AssertionResultData data = m_data; - - // Flip bool results if testFalse is set - if( m_exprComponents.testFalse ) { - if( data.resultType == ResultWas::Ok ) - data.resultType = ResultWas::ExpressionFailed; - else if( data.resultType == ResultWas::ExpressionFailed ) - data.resultType = ResultWas::Ok; - } - - data.message = m_stream.oss.str(); - data.reconstructedExpression = reconstructExpression(); - if( m_exprComponents.testFalse ) { - if( m_exprComponents.op == "" ) - data.reconstructedExpression = "!" + data.reconstructedExpression; - else - data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; - } - return AssertionResult( m_assertionInfo, data ); - } - std::string ResultBuilder::reconstructExpression() const { - if( m_exprComponents.op == "" ) - return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs; - else if( m_exprComponents.op == "matches" ) - return m_exprComponents.lhs + " " + m_exprComponents.rhs; - else if( m_exprComponents.op != "!" ) { - if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 && - m_exprComponents.lhs.find("\n") == std::string::npos && - m_exprComponents.rhs.find("\n") == std::string::npos ) - return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs; - else - return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs; - } - else - return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}"; - } - -} // end namespace Catch - -// #included from: catch_tag_alias_registry.hpp -#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED - -// #included from: catch_tag_alias_registry.h -#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED - -#include - -namespace Catch { - - class TagAliasRegistry : public ITagAliasRegistry { - public: - virtual ~TagAliasRegistry(); - virtual Option find( std::string const& alias ) const; - virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const; - void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); - static TagAliasRegistry& get(); - - private: - std::map m_registry; - }; - -} // end namespace Catch - -#include -#include - -namespace Catch { - - TagAliasRegistry::~TagAliasRegistry() {} - - Option TagAliasRegistry::find( std::string const& alias ) const { - std::map::const_iterator it = m_registry.find( alias ); - if( it != m_registry.end() ) - return it->second; - else - return Option(); - } - - std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { - std::string expandedTestSpec = unexpandedTestSpec; - for( std::map::const_iterator it = m_registry.begin(), itEnd = m_registry.end(); - it != itEnd; - ++it ) { - std::size_t pos = expandedTestSpec.find( it->first ); - if( pos != std::string::npos ) { - expandedTestSpec = expandedTestSpec.substr( 0, pos ) + - it->second.tag + - expandedTestSpec.substr( pos + it->first.size() ); - } - } - return expandedTestSpec; - } - - void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { - - if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) { - std::ostringstream oss; - oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo; - throw std::domain_error( oss.str().c_str() ); - } - if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) { - std::ostringstream oss; - oss << "error: tag alias, \"" << alias << "\" already registered.\n" - << "\tFirst seen at " << find(alias)->lineInfo << "\n" - << "\tRedefined at " << lineInfo; - throw std::domain_error( oss.str().c_str() ); - } - } - - TagAliasRegistry& TagAliasRegistry::get() { - static TagAliasRegistry instance; - return instance; - - } - - ITagAliasRegistry::~ITagAliasRegistry() {} - ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); } - - RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { - try { - TagAliasRegistry::get().add( alias, tag, lineInfo ); - } - catch( std::exception& ex ) { - Colour colourGuard( Colour::Red ); - Catch::cerr() << ex.what() << std::endl; - exit(1); - } - } - -} // end namespace Catch - -// #included from: ../reporters/catch_reporter_xml.hpp -#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED - -// #included from: catch_reporter_bases.hpp -#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED - -#include - -namespace Catch { - - struct StreamingReporterBase : SharedImpl { - - StreamingReporterBase( ReporterConfig const& _config ) - : m_config( _config.fullConfig() ), - stream( _config.stream() ) - {} - - virtual ~StreamingReporterBase(); - - virtual void noMatchingTestCases( std::string const& ) {} - - virtual void testRunStarting( TestRunInfo const& _testRunInfo ) { - currentTestRunInfo = _testRunInfo; - } - virtual void testGroupStarting( GroupInfo const& _groupInfo ) { - currentGroupInfo = _groupInfo; - } - - virtual void testCaseStarting( TestCaseInfo const& _testInfo ) { - currentTestCaseInfo = _testInfo; - } - virtual void sectionStarting( SectionInfo const& _sectionInfo ) { - m_sectionStack.push_back( _sectionInfo ); - } - - virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) { - m_sectionStack.pop_back(); - } - virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) { - currentTestCaseInfo.reset(); - } - virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) { - currentGroupInfo.reset(); - } - virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) { - currentTestCaseInfo.reset(); - currentGroupInfo.reset(); - currentTestRunInfo.reset(); - } - - virtual void skipTest( TestCaseInfo const& ) { - // Don't do anything with this by default. - // It can optionally be overridden in the derived class. - } - - Ptr m_config; - std::ostream& stream; - - LazyStat currentTestRunInfo; - LazyStat currentGroupInfo; - LazyStat currentTestCaseInfo; - - std::vector m_sectionStack; - }; - - struct CumulativeReporterBase : SharedImpl { - template - struct Node : SharedImpl<> { - explicit Node( T const& _value ) : value( _value ) {} - virtual ~Node() {} - - typedef std::vector > ChildNodes; - T value; - ChildNodes children; - }; - struct SectionNode : SharedImpl<> { - explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {} - virtual ~SectionNode(); - - bool operator == ( SectionNode const& other ) const { - return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo; - } - bool operator == ( Ptr const& other ) const { - return operator==( *other ); - } - - SectionStats stats; - typedef std::vector > ChildSections; - typedef std::vector Assertions; - ChildSections childSections; - Assertions assertions; - std::string stdOut; - std::string stdErr; - }; - - struct BySectionInfo { - BySectionInfo( SectionInfo const& other ) : m_other( other ) {} - BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {} - bool operator() ( Ptr const& node ) const { - return node->stats.sectionInfo.lineInfo == m_other.lineInfo; - } - private: - void operator=( BySectionInfo const& ); - SectionInfo const& m_other; - }; - - typedef Node TestCaseNode; - typedef Node TestGroupNode; - typedef Node TestRunNode; - - CumulativeReporterBase( ReporterConfig const& _config ) - : m_config( _config.fullConfig() ), - stream( _config.stream() ) - {} - ~CumulativeReporterBase(); - - virtual void testRunStarting( TestRunInfo const& ) {} - virtual void testGroupStarting( GroupInfo const& ) {} - - virtual void testCaseStarting( TestCaseInfo const& ) {} - - virtual void sectionStarting( SectionInfo const& sectionInfo ) { - SectionStats incompleteStats( sectionInfo, Counts(), 0, false ); - Ptr node; - if( m_sectionStack.empty() ) { - if( !m_rootSection ) - m_rootSection = new SectionNode( incompleteStats ); - node = m_rootSection; - } - else { - SectionNode& parentNode = *m_sectionStack.back(); - SectionNode::ChildSections::const_iterator it = - std::find_if( parentNode.childSections.begin(), - parentNode.childSections.end(), - BySectionInfo( sectionInfo ) ); - if( it == parentNode.childSections.end() ) { - node = new SectionNode( incompleteStats ); - parentNode.childSections.push_back( node ); - } - else - node = *it; - } - m_sectionStack.push_back( node ); - m_deepestSection = node; - } - - virtual void assertionStarting( AssertionInfo const& ) {} - - virtual bool assertionEnded( AssertionStats const& assertionStats ) { - assert( !m_sectionStack.empty() ); - SectionNode& sectionNode = *m_sectionStack.back(); - sectionNode.assertions.push_back( assertionStats ); - return true; - } - virtual void sectionEnded( SectionStats const& sectionStats ) { - assert( !m_sectionStack.empty() ); - SectionNode& node = *m_sectionStack.back(); - node.stats = sectionStats; - m_sectionStack.pop_back(); - } - virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { - Ptr node = new TestCaseNode( testCaseStats ); - assert( m_sectionStack.size() == 0 ); - node->children.push_back( m_rootSection ); - m_testCases.push_back( node ); - m_rootSection.reset(); - - assert( m_deepestSection ); - m_deepestSection->stdOut = testCaseStats.stdOut; - m_deepestSection->stdErr = testCaseStats.stdErr; - } - virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { - Ptr node = new TestGroupNode( testGroupStats ); - node->children.swap( m_testCases ); - m_testGroups.push_back( node ); - } - virtual void testRunEnded( TestRunStats const& testRunStats ) { - Ptr node = new TestRunNode( testRunStats ); - node->children.swap( m_testGroups ); - m_testRuns.push_back( node ); - testRunEndedCumulative(); - } - virtual void testRunEndedCumulative() = 0; - - virtual void skipTest( TestCaseInfo const& ) {} - - Ptr m_config; - std::ostream& stream; - std::vector m_assertions; - std::vector > > m_sections; - std::vector > m_testCases; - std::vector > m_testGroups; - - std::vector > m_testRuns; - - Ptr m_rootSection; - Ptr m_deepestSection; - std::vector > m_sectionStack; - - }; - - template - char const* getLineOfChars() { - static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0}; - if( !*line ) { - memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 ); - line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0; - } - return line; - } - -} // end namespace Catch - -// #included from: ../internal/catch_reporter_registrars.hpp -#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED - -namespace Catch { - - template - class LegacyReporterRegistrar { - - class ReporterFactory : public IReporterFactory { - virtual IStreamingReporter* create( ReporterConfig const& config ) const { - return new LegacyReporterAdapter( new T( config ) ); - } - - virtual std::string getDescription() const { - return T::getDescription(); - } - }; - - public: - - LegacyReporterRegistrar( std::string const& name ) { - getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); - } - }; - - template - class ReporterRegistrar { - - class ReporterFactory : public IReporterFactory { - - // *** Please Note ***: - // - If you end up here looking at a compiler error because it's trying to register - // your custom reporter class be aware that the native reporter interface has changed - // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via - // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter. - // However please consider updating to the new interface as the old one is now - // deprecated and will probably be removed quite soon! - // Please contact me via github if you have any questions at all about this. - // In fact, ideally, please contact me anyway to let me know you've hit this - as I have - // no idea who is actually using custom reporters at all (possibly no-one!). - // The new interface is designed to minimise exposure to interface changes in the future. - virtual IStreamingReporter* create( ReporterConfig const& config ) const { - return new T( config ); - } - - virtual std::string getDescription() const { - return T::getDescription(); - } - }; - - public: - - ReporterRegistrar( std::string const& name ) { - getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); - } - }; -} - -#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \ - namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } -#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \ - namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } - -// #included from: ../internal/catch_xmlwriter.hpp -#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED - -#include -#include -#include - -namespace Catch { - - class XmlWriter { - public: - - class ScopedElement { - public: - ScopedElement( XmlWriter* writer ) - : m_writer( writer ) - {} - - ScopedElement( ScopedElement const& other ) - : m_writer( other.m_writer ){ - other.m_writer = NULL; - } - - ~ScopedElement() { - if( m_writer ) - m_writer->endElement(); - } - - ScopedElement& writeText( std::string const& text, bool indent = true ) { - m_writer->writeText( text, indent ); - return *this; - } - - template - ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { - m_writer->writeAttribute( name, attribute ); - return *this; - } - - private: - mutable XmlWriter* m_writer; - }; - - XmlWriter() - : m_tagIsOpen( false ), - m_needsNewline( false ), - m_os( &Catch::cout() ) - {} - - XmlWriter( std::ostream& os ) - : m_tagIsOpen( false ), - m_needsNewline( false ), - m_os( &os ) - {} - - ~XmlWriter() { - while( !m_tags.empty() ) - endElement(); - } - - XmlWriter& startElement( std::string const& name ) { - ensureTagClosed(); - newlineIfNecessary(); - stream() << m_indent << "<" << name; - m_tags.push_back( name ); - m_indent += " "; - m_tagIsOpen = true; - return *this; - } - - ScopedElement scopedElement( std::string const& name ) { - ScopedElement scoped( this ); - startElement( name ); - return scoped; - } - - XmlWriter& endElement() { - newlineIfNecessary(); - m_indent = m_indent.substr( 0, m_indent.size()-2 ); - if( m_tagIsOpen ) { - stream() << "/>\n"; - m_tagIsOpen = false; - } - else { - stream() << m_indent << "\n"; - } - m_tags.pop_back(); - return *this; - } - - XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) { - if( !name.empty() && !attribute.empty() ) { - stream() << " " << name << "=\""; - writeEncodedText( attribute ); - stream() << "\""; - } - return *this; - } - - XmlWriter& writeAttribute( std::string const& name, bool attribute ) { - stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\""; - return *this; - } - - template - XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { - if( !name.empty() ) - stream() << " " << name << "=\"" << attribute << "\""; - return *this; - } - - XmlWriter& writeText( std::string const& text, bool indent = true ) { - if( !text.empty() ){ - bool tagWasOpen = m_tagIsOpen; - ensureTagClosed(); - if( tagWasOpen && indent ) - stream() << m_indent; - writeEncodedText( text ); - m_needsNewline = true; - } - return *this; - } - - XmlWriter& writeComment( std::string const& text ) { - ensureTagClosed(); - stream() << m_indent << ""; - m_needsNewline = true; - return *this; - } - - XmlWriter& writeBlankLine() { - ensureTagClosed(); - stream() << "\n"; - return *this; - } - - void setStream( std::ostream& os ) { - m_os = &os; - } - - private: - XmlWriter( XmlWriter const& ); - void operator=( XmlWriter const& ); - - std::ostream& stream() { - return *m_os; - } - - void ensureTagClosed() { - if( m_tagIsOpen ) { - stream() << ">\n"; - m_tagIsOpen = false; - } - } - - void newlineIfNecessary() { - if( m_needsNewline ) { - stream() << "\n"; - m_needsNewline = false; - } - } - - void writeEncodedText( std::string const& text ) { - static const char* charsToEncode = "<&\""; - std::string mtext = text; - std::string::size_type pos = mtext.find_first_of( charsToEncode ); - while( pos != std::string::npos ) { - stream() << mtext.substr( 0, pos ); - - switch( mtext[pos] ) { - case '<': - stream() << "<"; - break; - case '&': - stream() << "&"; - break; - case '\"': - stream() << """; - break; - } - mtext = mtext.substr( pos+1 ); - pos = mtext.find_first_of( charsToEncode ); - } - stream() << mtext; - } - - bool m_tagIsOpen; - bool m_needsNewline; - std::vector m_tags; - std::string m_indent; - std::ostream* m_os; - }; - -} -namespace Catch { - class XmlReporter : public StreamingReporterBase { - public: - XmlReporter( ReporterConfig const& _config ) - : StreamingReporterBase( _config ), - m_sectionDepth( 0 ) - {} - - virtual ~XmlReporter(); - - static std::string getDescription() { - return "Reports test results as an XML document"; - } - - public: // StreamingReporterBase - virtual ReporterPreferences getPreferences() const { - ReporterPreferences prefs; - prefs.shouldRedirectStdOut = true; - return prefs; - } - - virtual void noMatchingTestCases( std::string const& s ) { - StreamingReporterBase::noMatchingTestCases( s ); - } - - virtual void testRunStarting( TestRunInfo const& testInfo ) { - StreamingReporterBase::testRunStarting( testInfo ); - m_xml.setStream( stream ); - m_xml.startElement( "Catch" ); - if( !m_config->name().empty() ) - m_xml.writeAttribute( "name", m_config->name() ); - } - - virtual void testGroupStarting( GroupInfo const& groupInfo ) { - StreamingReporterBase::testGroupStarting( groupInfo ); - m_xml.startElement( "Group" ) - .writeAttribute( "name", groupInfo.name ); - } - - virtual void testCaseStarting( TestCaseInfo const& testInfo ) { - StreamingReporterBase::testCaseStarting(testInfo); - m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) ); - - if ( m_config->showDurations() == ShowDurations::Always ) - m_testCaseTimer.start(); - } - - virtual void sectionStarting( SectionInfo const& sectionInfo ) { - StreamingReporterBase::sectionStarting( sectionInfo ); - if( m_sectionDepth++ > 0 ) { - m_xml.startElement( "Section" ) - .writeAttribute( "name", trim( sectionInfo.name ) ) - .writeAttribute( "description", sectionInfo.description ); - } - } - - virtual void assertionStarting( AssertionInfo const& ) { } - - virtual bool assertionEnded( AssertionStats const& assertionStats ) { - const AssertionResult& assertionResult = assertionStats.assertionResult; - - // Print any info messages in tags. - if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { - for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); - it != itEnd; - ++it ) { - if( it->type == ResultWas::Info ) { - m_xml.scopedElement( "Info" ) - .writeText( it->message ); - } else if ( it->type == ResultWas::Warning ) { - m_xml.scopedElement( "Warning" ) - .writeText( it->message ); - } - } - } - - // Drop out if result was successful but we're not printing them. - if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) ) - return true; - - // Print the expression if there is one. - if( assertionResult.hasExpression() ) { - m_xml.startElement( "Expression" ) - .writeAttribute( "success", assertionResult.succeeded() ) - .writeAttribute( "type", assertionResult.getTestMacroName() ) - .writeAttribute( "filename", assertionResult.getSourceInfo().file ) - .writeAttribute( "line", assertionResult.getSourceInfo().line ); - - m_xml.scopedElement( "Original" ) - .writeText( assertionResult.getExpression() ); - m_xml.scopedElement( "Expanded" ) - .writeText( assertionResult.getExpandedExpression() ); - } - - // And... Print a result applicable to each result type. - switch( assertionResult.getResultType() ) { - case ResultWas::ThrewException: - m_xml.scopedElement( "Exception" ) - .writeAttribute( "filename", assertionResult.getSourceInfo().file ) - .writeAttribute( "line", assertionResult.getSourceInfo().line ) - .writeText( assertionResult.getMessage() ); - break; - case ResultWas::FatalErrorCondition: - m_xml.scopedElement( "Fatal Error Condition" ) - .writeAttribute( "filename", assertionResult.getSourceInfo().file ) - .writeAttribute( "line", assertionResult.getSourceInfo().line ) - .writeText( assertionResult.getMessage() ); - break; - case ResultWas::Info: - m_xml.scopedElement( "Info" ) - .writeText( assertionResult.getMessage() ); - break; - case ResultWas::Warning: - // Warning will already have been written - break; - case ResultWas::ExplicitFailure: - m_xml.scopedElement( "Failure" ) - .writeText( assertionResult.getMessage() ); - break; - default: - break; - } - - if( assertionResult.hasExpression() ) - m_xml.endElement(); - - return true; - } - - virtual void sectionEnded( SectionStats const& sectionStats ) { - StreamingReporterBase::sectionEnded( sectionStats ); - if( --m_sectionDepth > 0 ) { - XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); - e.writeAttribute( "successes", sectionStats.assertions.passed ); - e.writeAttribute( "failures", sectionStats.assertions.failed ); - e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk ); - - if ( m_config->showDurations() == ShowDurations::Always ) - e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds ); - - m_xml.endElement(); - } - } - - virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { - StreamingReporterBase::testCaseEnded( testCaseStats ); - XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); - e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() ); - - if ( m_config->showDurations() == ShowDurations::Always ) - e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() ); - - m_xml.endElement(); - } - - virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { - StreamingReporterBase::testGroupEnded( testGroupStats ); - // TODO: Check testGroupStats.aborting and act accordingly. - m_xml.scopedElement( "OverallResults" ) - .writeAttribute( "successes", testGroupStats.totals.assertions.passed ) - .writeAttribute( "failures", testGroupStats.totals.assertions.failed ) - .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk ); - m_xml.endElement(); - } - - virtual void testRunEnded( TestRunStats const& testRunStats ) { - StreamingReporterBase::testRunEnded( testRunStats ); - m_xml.scopedElement( "OverallResults" ) - .writeAttribute( "successes", testRunStats.totals.assertions.passed ) - .writeAttribute( "failures", testRunStats.totals.assertions.failed ) - .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk ); - m_xml.endElement(); - } - - private: - Timer m_testCaseTimer; - XmlWriter m_xml; - int m_sectionDepth; - }; - - INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter ) - -} // end namespace Catch - -// #included from: ../reporters/catch_reporter_junit.hpp -#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED - -#include - -namespace Catch { - - class JunitReporter : public CumulativeReporterBase { - public: - JunitReporter( ReporterConfig const& _config ) - : CumulativeReporterBase( _config ), - xml( _config.stream() ) - {} - - ~JunitReporter(); - - static std::string getDescription() { - return "Reports test results in an XML format that looks like Ant's junitreport target"; - } - - virtual void noMatchingTestCases( std::string const& /*spec*/ ) {} - - virtual ReporterPreferences getPreferences() const { - ReporterPreferences prefs; - prefs.shouldRedirectStdOut = true; - return prefs; - } - - virtual void testRunStarting( TestRunInfo const& runInfo ) { - CumulativeReporterBase::testRunStarting( runInfo ); - xml.startElement( "testsuites" ); - } - - virtual void testGroupStarting( GroupInfo const& groupInfo ) { - suiteTimer.start(); - stdOutForSuite.str(""); - stdErrForSuite.str(""); - unexpectedExceptions = 0; - CumulativeReporterBase::testGroupStarting( groupInfo ); - } - - virtual bool assertionEnded( AssertionStats const& assertionStats ) { - if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException ) - unexpectedExceptions++; - return CumulativeReporterBase::assertionEnded( assertionStats ); - } - - virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { - stdOutForSuite << testCaseStats.stdOut; - stdErrForSuite << testCaseStats.stdErr; - CumulativeReporterBase::testCaseEnded( testCaseStats ); - } - - virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { - double suiteTime = suiteTimer.getElapsedSeconds(); - CumulativeReporterBase::testGroupEnded( testGroupStats ); - writeGroup( *m_testGroups.back(), suiteTime ); - } - - virtual void testRunEndedCumulative() { - xml.endElement(); - } - - void writeGroup( TestGroupNode const& groupNode, double suiteTime ) { - XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); - TestGroupStats const& stats = groupNode.value; - xml.writeAttribute( "name", stats.groupInfo.name ); - xml.writeAttribute( "errors", unexpectedExceptions ); - xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions ); - xml.writeAttribute( "tests", stats.totals.assertions.total() ); - xml.writeAttribute( "hostname", "tbd" ); // !TBD - if( m_config->showDurations() == ShowDurations::Never ) - xml.writeAttribute( "time", "" ); - else - xml.writeAttribute( "time", suiteTime ); - xml.writeAttribute( "timestamp", "tbd" ); // !TBD - - // Write test cases - for( TestGroupNode::ChildNodes::const_iterator - it = groupNode.children.begin(), itEnd = groupNode.children.end(); - it != itEnd; - ++it ) - writeTestCase( **it ); - - xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false ); - xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false ); - } - - void writeTestCase( TestCaseNode const& testCaseNode ) { - TestCaseStats const& stats = testCaseNode.value; - - // All test cases have exactly one section - which represents the - // test case itself. That section may have 0-n nested sections - assert( testCaseNode.children.size() == 1 ); - SectionNode const& rootSection = *testCaseNode.children.front(); - - std::string className = stats.testInfo.className; - - if( className.empty() ) { - if( rootSection.childSections.empty() ) - className = "global"; - } - writeSection( className, "", rootSection ); - } - - void writeSection( std::string const& className, - std::string const& rootName, - SectionNode const& sectionNode ) { - std::string name = trim( sectionNode.stats.sectionInfo.name ); - if( !rootName.empty() ) - name = rootName + "/" + name; - - if( !sectionNode.assertions.empty() || - !sectionNode.stdOut.empty() || - !sectionNode.stdErr.empty() ) { - XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); - if( className.empty() ) { - xml.writeAttribute( "classname", name ); - xml.writeAttribute( "name", "root" ); - } - else { - xml.writeAttribute( "classname", className ); - xml.writeAttribute( "name", name ); - } - xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) ); - - writeAssertions( sectionNode ); - - if( !sectionNode.stdOut.empty() ) - xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false ); - if( !sectionNode.stdErr.empty() ) - xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false ); - } - for( SectionNode::ChildSections::const_iterator - it = sectionNode.childSections.begin(), - itEnd = sectionNode.childSections.end(); - it != itEnd; - ++it ) - if( className.empty() ) - writeSection( name, "", **it ); - else - writeSection( className, name, **it ); - } - - void writeAssertions( SectionNode const& sectionNode ) { - for( SectionNode::Assertions::const_iterator - it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end(); - it != itEnd; - ++it ) - writeAssertion( *it ); - } - void writeAssertion( AssertionStats const& stats ) { - AssertionResult const& result = stats.assertionResult; - if( !result.isOk() ) { - std::string elementName; - switch( result.getResultType() ) { - case ResultWas::ThrewException: - case ResultWas::FatalErrorCondition: - elementName = "error"; - break; - case ResultWas::ExplicitFailure: - elementName = "failure"; - break; - case ResultWas::ExpressionFailed: - elementName = "failure"; - break; - case ResultWas::DidntThrowException: - elementName = "failure"; - break; - - // We should never see these here: - case ResultWas::Info: - case ResultWas::Warning: - case ResultWas::Ok: - case ResultWas::Unknown: - case ResultWas::FailureBit: - case ResultWas::Exception: - elementName = "internalError"; - break; - } - - XmlWriter::ScopedElement e = xml.scopedElement( elementName ); - - xml.writeAttribute( "message", result.getExpandedExpression() ); - xml.writeAttribute( "type", result.getTestMacroName() ); - - std::ostringstream oss; - if( !result.getMessage().empty() ) - oss << result.getMessage() << "\n"; - for( std::vector::const_iterator - it = stats.infoMessages.begin(), - itEnd = stats.infoMessages.end(); - it != itEnd; - ++it ) - if( it->type == ResultWas::Info ) - oss << it->message << "\n"; - - oss << "at " << result.getSourceInfo(); - xml.writeText( oss.str(), false ); - } - } - - XmlWriter xml; - Timer suiteTimer; - std::ostringstream stdOutForSuite; - std::ostringstream stdErrForSuite; - unsigned int unexpectedExceptions; - }; - - INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter ) - -} // end namespace Catch - -// #included from: ../reporters/catch_reporter_console.hpp -#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED - -namespace Catch { - - struct ConsoleReporter : StreamingReporterBase { - ConsoleReporter( ReporterConfig const& _config ) - : StreamingReporterBase( _config ), - m_headerPrinted( false ) - {} - - virtual ~ConsoleReporter(); - static std::string getDescription() { - return "Reports test results as plain lines of text"; - } - virtual ReporterPreferences getPreferences() const { - ReporterPreferences prefs; - prefs.shouldRedirectStdOut = false; - return prefs; - } - - virtual void noMatchingTestCases( std::string const& spec ) { - stream << "No test cases matched '" << spec << "'" << std::endl; - } - - virtual void assertionStarting( AssertionInfo const& ) { - } - - virtual bool assertionEnded( AssertionStats const& _assertionStats ) { - AssertionResult const& result = _assertionStats.assertionResult; - - bool printInfoMessages = true; - - // Drop out if result was successful and we're not printing those - if( !m_config->includeSuccessfulResults() && result.isOk() ) { - if( result.getResultType() != ResultWas::Warning ) - return false; - printInfoMessages = false; - } - - lazyPrint(); - - AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); - printer.print(); - stream << std::endl; - return true; - } - - virtual void sectionStarting( SectionInfo const& _sectionInfo ) { - m_headerPrinted = false; - StreamingReporterBase::sectionStarting( _sectionInfo ); - } - virtual void sectionEnded( SectionStats const& _sectionStats ) { - if( _sectionStats.missingAssertions ) { - lazyPrint(); - Colour colour( Colour::ResultError ); - if( m_sectionStack.size() > 1 ) - stream << "\nNo assertions in section"; - else - stream << "\nNo assertions in test case"; - stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl; - } - if( m_headerPrinted ) { - if( m_config->showDurations() == ShowDurations::Always ) - stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl; - m_headerPrinted = false; - } - else { - if( m_config->showDurations() == ShowDurations::Always ) - stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl; - } - StreamingReporterBase::sectionEnded( _sectionStats ); - } - - virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) { - StreamingReporterBase::testCaseEnded( _testCaseStats ); - m_headerPrinted = false; - } - virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) { - if( currentGroupInfo.used ) { - printSummaryDivider(); - stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n"; - printTotals( _testGroupStats.totals ); - stream << "\n" << std::endl; - } - StreamingReporterBase::testGroupEnded( _testGroupStats ); - } - virtual void testRunEnded( TestRunStats const& _testRunStats ) { - printTotalsDivider( _testRunStats.totals ); - printTotals( _testRunStats.totals ); - stream << std::endl; - StreamingReporterBase::testRunEnded( _testRunStats ); - } - - private: - - class AssertionPrinter { - void operator= ( AssertionPrinter const& ); - public: - AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) - : stream( _stream ), - stats( _stats ), - result( _stats.assertionResult ), - colour( Colour::None ), - message( result.getMessage() ), - messages( _stats.infoMessages ), - printInfoMessages( _printInfoMessages ) - { - switch( result.getResultType() ) { - case ResultWas::Ok: - colour = Colour::Success; - passOrFail = "PASSED"; - //if( result.hasMessage() ) - if( _stats.infoMessages.size() == 1 ) - messageLabel = "with message"; - if( _stats.infoMessages.size() > 1 ) - messageLabel = "with messages"; - break; - case ResultWas::ExpressionFailed: - if( result.isOk() ) { - colour = Colour::Success; - passOrFail = "FAILED - but was ok"; - } - else { - colour = Colour::Error; - passOrFail = "FAILED"; - } - if( _stats.infoMessages.size() == 1 ) - messageLabel = "with message"; - if( _stats.infoMessages.size() > 1 ) - messageLabel = "with messages"; - break; - case ResultWas::ThrewException: - colour = Colour::Error; - passOrFail = "FAILED"; - messageLabel = "due to unexpected exception with message"; - break; - case ResultWas::FatalErrorCondition: - colour = Colour::Error; - passOrFail = "FAILED"; - messageLabel = "due to a fatal error condition"; - break; - case ResultWas::DidntThrowException: - colour = Colour::Error; - passOrFail = "FAILED"; - messageLabel = "because no exception was thrown where one was expected"; - break; - case ResultWas::Info: - messageLabel = "info"; - break; - case ResultWas::Warning: - messageLabel = "warning"; - break; - case ResultWas::ExplicitFailure: - passOrFail = "FAILED"; - colour = Colour::Error; - if( _stats.infoMessages.size() == 1 ) - messageLabel = "explicitly with message"; - if( _stats.infoMessages.size() > 1 ) - messageLabel = "explicitly with messages"; - break; - // These cases are here to prevent compiler warnings - case ResultWas::Unknown: - case ResultWas::FailureBit: - case ResultWas::Exception: - passOrFail = "** internal error **"; - colour = Colour::Error; - break; - } - } - - void print() const { - printSourceInfo(); - if( stats.totals.assertions.total() > 0 ) { - if( result.isOk() ) - stream << "\n"; - printResultType(); - printOriginalExpression(); - printReconstructedExpression(); - } - else { - stream << "\n"; - } - printMessage(); - } - - private: - void printResultType() const { - if( !passOrFail.empty() ) { - Colour colourGuard( colour ); - stream << passOrFail << ":\n"; - } - } - void printOriginalExpression() const { - if( result.hasExpression() ) { - Colour colourGuard( Colour::OriginalExpression ); - stream << " "; - stream << result.getExpressionInMacro(); - stream << "\n"; - } - } - void printReconstructedExpression() const { - if( result.hasExpandedExpression() ) { - stream << "with expansion:\n"; - Colour colourGuard( Colour::ReconstructedExpression ); - stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n"; - } - } - void printMessage() const { - if( !messageLabel.empty() ) - stream << messageLabel << ":" << "\n"; - for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end(); - it != itEnd; - ++it ) { - // If this assertion is a warning ignore any INFO messages - if( printInfoMessages || it->type != ResultWas::Info ) - stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n"; - } - } - void printSourceInfo() const { - Colour colourGuard( Colour::FileName ); - stream << result.getSourceInfo() << ": "; - } - - std::ostream& stream; - AssertionStats const& stats; - AssertionResult const& result; - Colour::Code colour; - std::string passOrFail; - std::string messageLabel; - std::string message; - std::vector messages; - bool printInfoMessages; - }; - - void lazyPrint() { - - if( !currentTestRunInfo.used ) - lazyPrintRunInfo(); - if( !currentGroupInfo.used ) - lazyPrintGroupInfo(); - - if( !m_headerPrinted ) { - printTestCaseAndSectionHeader(); - m_headerPrinted = true; - } - } - void lazyPrintRunInfo() { - stream << "\n" << getLineOfChars<'~'>() << "\n"; - Colour colour( Colour::SecondaryText ); - stream << currentTestRunInfo->name - << " is a Catch v" << libraryVersion.majorVersion << "." - << libraryVersion.minorVersion << " b" - << libraryVersion.buildNumber; - if( libraryVersion.branchName != std::string( "master" ) ) - stream << " (" << libraryVersion.branchName << ")"; - stream << " host application.\n" - << "Run with -? for options\n\n"; - - if( m_config->rngSeed() != 0 ) - stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n"; - - currentTestRunInfo.used = true; - } - void lazyPrintGroupInfo() { - if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) { - printClosedHeader( "Group: " + currentGroupInfo->name ); - currentGroupInfo.used = true; - } - } - void printTestCaseAndSectionHeader() { - assert( !m_sectionStack.empty() ); - printOpenHeader( currentTestCaseInfo->name ); - - if( m_sectionStack.size() > 1 ) { - Colour colourGuard( Colour::Headers ); - - std::vector::const_iterator - it = m_sectionStack.begin()+1, // Skip first section (test case) - itEnd = m_sectionStack.end(); - for( ; it != itEnd; ++it ) - printHeaderString( it->name, 2 ); - } - - SourceLineInfo lineInfo = m_sectionStack.front().lineInfo; - - if( !lineInfo.empty() ){ - stream << getLineOfChars<'-'>() << "\n"; - Colour colourGuard( Colour::FileName ); - stream << lineInfo << "\n"; - } - stream << getLineOfChars<'.'>() << "\n" << std::endl; - } - - void printClosedHeader( std::string const& _name ) { - printOpenHeader( _name ); - stream << getLineOfChars<'.'>() << "\n"; - } - void printOpenHeader( std::string const& _name ) { - stream << getLineOfChars<'-'>() << "\n"; - { - Colour colourGuard( Colour::Headers ); - printHeaderString( _name ); - } - } - - // if string has a : in first line will set indent to follow it on - // subsequent lines - void printHeaderString( std::string const& _string, std::size_t indent = 0 ) { - std::size_t i = _string.find( ": " ); - if( i != std::string::npos ) - i+=2; - else - i = 0; - stream << Text( _string, TextAttributes() - .setIndent( indent+i) - .setInitialIndent( indent ) ) << "\n"; - } - - struct SummaryColumn { - - SummaryColumn( std::string const& _label, Colour::Code _colour ) - : label( _label ), - colour( _colour ) - {} - SummaryColumn addRow( std::size_t count ) { - std::ostringstream oss; - oss << count; - std::string row = oss.str(); - for( std::vector::iterator it = rows.begin(); it != rows.end(); ++it ) { - while( it->size() < row.size() ) - *it = " " + *it; - while( it->size() > row.size() ) - row = " " + row; - } - rows.push_back( row ); - return *this; - } - - std::string label; - Colour::Code colour; - std::vector rows; - - }; - - void printTotals( Totals const& totals ) { - if( totals.testCases.total() == 0 ) { - stream << Colour( Colour::Warning ) << "No tests ran\n"; - } - else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) { - stream << Colour( Colour::ResultSuccess ) << "All tests passed"; - stream << " (" - << pluralise( totals.assertions.passed, "assertion" ) << " in " - << pluralise( totals.testCases.passed, "test case" ) << ")" - << "\n"; - } - else { - - std::vector columns; - columns.push_back( SummaryColumn( "", Colour::None ) - .addRow( totals.testCases.total() ) - .addRow( totals.assertions.total() ) ); - columns.push_back( SummaryColumn( "passed", Colour::Success ) - .addRow( totals.testCases.passed ) - .addRow( totals.assertions.passed ) ); - columns.push_back( SummaryColumn( "failed", Colour::ResultError ) - .addRow( totals.testCases.failed ) - .addRow( totals.assertions.failed ) ); - columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) - .addRow( totals.testCases.failedButOk ) - .addRow( totals.assertions.failedButOk ) ); - - printSummaryRow( "test cases", columns, 0 ); - printSummaryRow( "assertions", columns, 1 ); - } - } - void printSummaryRow( std::string const& label, std::vector const& cols, std::size_t row ) { - for( std::vector::const_iterator it = cols.begin(); it != cols.end(); ++it ) { - std::string value = it->rows[row]; - if( it->label.empty() ) { - stream << label << ": "; - if( value != "0" ) - stream << value; - else - stream << Colour( Colour::Warning ) << "- none -"; - } - else if( value != "0" ) { - stream << Colour( Colour::LightGrey ) << " | "; - stream << Colour( it->colour ) - << value << " " << it->label; - } - } - stream << "\n"; - } - - static std::size_t makeRatio( std::size_t number, std::size_t total ) { - std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0; - return ( ratio == 0 && number > 0 ) ? 1 : ratio; - } - static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) { - if( i > j && i > k ) - return i; - else if( j > k ) - return j; - else - return k; - } - - void printTotalsDivider( Totals const& totals ) { - if( totals.testCases.total() > 0 ) { - std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() ); - std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() ); - std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() ); - while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 ) - findMax( failedRatio, failedButOkRatio, passedRatio )++; - while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 ) - findMax( failedRatio, failedButOkRatio, passedRatio )--; - - stream << Colour( Colour::Error ) << std::string( failedRatio, '=' ); - stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' ); - if( totals.testCases.allPassed() ) - stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' ); - else - stream << Colour( Colour::Success ) << std::string( passedRatio, '=' ); - } - else { - stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' ); - } - stream << "\n"; - } - void printSummaryDivider() { - stream << getLineOfChars<'-'>() << "\n"; - } - - private: - bool m_headerPrinted; - }; - - INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter ) - -} // end namespace Catch - -// #included from: ../reporters/catch_reporter_compact.hpp -#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED - -namespace Catch { - - struct CompactReporter : StreamingReporterBase { - - CompactReporter( ReporterConfig const& _config ) - : StreamingReporterBase( _config ) - {} - - virtual ~CompactReporter(); - - static std::string getDescription() { - return "Reports test results on a single line, suitable for IDEs"; - } - - virtual ReporterPreferences getPreferences() const { - ReporterPreferences prefs; - prefs.shouldRedirectStdOut = false; - return prefs; - } - - virtual void noMatchingTestCases( std::string const& spec ) { - stream << "No test cases matched '" << spec << "'" << std::endl; - } - - virtual void assertionStarting( AssertionInfo const& ) { - } - - virtual bool assertionEnded( AssertionStats const& _assertionStats ) { - AssertionResult const& result = _assertionStats.assertionResult; - - bool printInfoMessages = true; - - // Drop out if result was successful and we're not printing those - if( !m_config->includeSuccessfulResults() && result.isOk() ) { - if( result.getResultType() != ResultWas::Warning ) - return false; - printInfoMessages = false; - } - - AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); - printer.print(); - - stream << std::endl; - return true; - } - - virtual void testRunEnded( TestRunStats const& _testRunStats ) { - printTotals( _testRunStats.totals ); - stream << "\n" << std::endl; - StreamingReporterBase::testRunEnded( _testRunStats ); - } - - private: - class AssertionPrinter { - void operator= ( AssertionPrinter const& ); - public: - AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) - : stream( _stream ) - , stats( _stats ) - , result( _stats.assertionResult ) - , messages( _stats.infoMessages ) - , itMessage( _stats.infoMessages.begin() ) - , printInfoMessages( _printInfoMessages ) - {} - - void print() { - printSourceInfo(); - - itMessage = messages.begin(); - - switch( result.getResultType() ) { - case ResultWas::Ok: - printResultType( Colour::ResultSuccess, passedString() ); - printOriginalExpression(); - printReconstructedExpression(); - if ( ! result.hasExpression() ) - printRemainingMessages( Colour::None ); - else - printRemainingMessages(); - break; - case ResultWas::ExpressionFailed: - if( result.isOk() ) - printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) ); - else - printResultType( Colour::Error, failedString() ); - printOriginalExpression(); - printReconstructedExpression(); - printRemainingMessages(); - break; - case ResultWas::ThrewException: - printResultType( Colour::Error, failedString() ); - printIssue( "unexpected exception with message:" ); - printMessage(); - printExpressionWas(); - printRemainingMessages(); - break; - case ResultWas::FatalErrorCondition: - printResultType( Colour::Error, failedString() ); - printIssue( "fatal error condition with message:" ); - printMessage(); - printExpressionWas(); - printRemainingMessages(); - break; - case ResultWas::DidntThrowException: - printResultType( Colour::Error, failedString() ); - printIssue( "expected exception, got none" ); - printExpressionWas(); - printRemainingMessages(); - break; - case ResultWas::Info: - printResultType( Colour::None, "info" ); - printMessage(); - printRemainingMessages(); - break; - case ResultWas::Warning: - printResultType( Colour::None, "warning" ); - printMessage(); - printRemainingMessages(); - break; - case ResultWas::ExplicitFailure: - printResultType( Colour::Error, failedString() ); - printIssue( "explicitly" ); - printRemainingMessages( Colour::None ); - break; - // These cases are here to prevent compiler warnings - case ResultWas::Unknown: - case ResultWas::FailureBit: - case ResultWas::Exception: - printResultType( Colour::Error, "** internal error **" ); - break; - } - } - - private: - // Colour::LightGrey - - static Colour::Code dimColour() { return Colour::FileName; } - -#ifdef CATCH_PLATFORM_MAC - static const char* failedString() { return "FAILED"; } - static const char* passedString() { return "PASSED"; } -#else - static const char* failedString() { return "failed"; } - static const char* passedString() { return "passed"; } -#endif - - void printSourceInfo() const { - Colour colourGuard( Colour::FileName ); - stream << result.getSourceInfo() << ":"; - } - - void printResultType( Colour::Code colour, std::string passOrFail ) const { - if( !passOrFail.empty() ) { - { - Colour colourGuard( colour ); - stream << " " << passOrFail; - } - stream << ":"; - } - } - - void printIssue( std::string issue ) const { - stream << " " << issue; - } - - void printExpressionWas() { - if( result.hasExpression() ) { - stream << ";"; - { - Colour colour( dimColour() ); - stream << " expression was:"; - } - printOriginalExpression(); - } - } - - void printOriginalExpression() const { - if( result.hasExpression() ) { - stream << " " << result.getExpression(); - } - } - - void printReconstructedExpression() const { - if( result.hasExpandedExpression() ) { - { - Colour colour( dimColour() ); - stream << " for: "; - } - stream << result.getExpandedExpression(); - } - } - - void printMessage() { - if ( itMessage != messages.end() ) { - stream << " '" << itMessage->message << "'"; - ++itMessage; - } - } - - void printRemainingMessages( Colour::Code colour = dimColour() ) { - if ( itMessage == messages.end() ) - return; - - // using messages.end() directly yields compilation error: - std::vector::const_iterator itEnd = messages.end(); - const std::size_t N = static_cast( std::distance( itMessage, itEnd ) ); - - { - Colour colourGuard( colour ); - stream << " with " << pluralise( N, "message" ) << ":"; - } - - for(; itMessage != itEnd; ) { - // If this assertion is a warning ignore any INFO messages - if( printInfoMessages || itMessage->type != ResultWas::Info ) { - stream << " '" << itMessage->message << "'"; - if ( ++itMessage != itEnd ) { - Colour colourGuard( dimColour() ); - stream << " and"; - } - } - } - } - - private: - std::ostream& stream; - AssertionStats const& stats; - AssertionResult const& result; - std::vector messages; - std::vector::const_iterator itMessage; - bool printInfoMessages; - }; - - // Colour, message variants: - // - white: No tests ran. - // - red: Failed [both/all] N test cases, failed [both/all] M assertions. - // - white: Passed [both/all] N test cases (no assertions). - // - red: Failed N tests cases, failed M assertions. - // - green: Passed [both/all] N tests cases with M assertions. - - std::string bothOrAll( std::size_t count ) const { - return count == 1 ? "" : count == 2 ? "both " : "all " ; - } - - void printTotals( const Totals& totals ) const { - if( totals.testCases.total() == 0 ) { - stream << "No tests ran."; - } - else if( totals.testCases.failed == totals.testCases.total() ) { - Colour colour( Colour::ResultError ); - const std::string qualify_assertions_failed = - totals.assertions.failed == totals.assertions.total() ? - bothOrAll( totals.assertions.failed ) : ""; - stream << - "Failed " << bothOrAll( totals.testCases.failed ) - << pluralise( totals.testCases.failed, "test case" ) << ", " - "failed " << qualify_assertions_failed << - pluralise( totals.assertions.failed, "assertion" ) << "."; - } - else if( totals.assertions.total() == 0 ) { - stream << - "Passed " << bothOrAll( totals.testCases.total() ) - << pluralise( totals.testCases.total(), "test case" ) - << " (no assertions)."; - } - else if( totals.assertions.failed ) { - Colour colour( Colour::ResultError ); - stream << - "Failed " << pluralise( totals.testCases.failed, "test case" ) << ", " - "failed " << pluralise( totals.assertions.failed, "assertion" ) << "."; - } - else { - Colour colour( Colour::ResultSuccess ); - stream << - "Passed " << bothOrAll( totals.testCases.passed ) - << pluralise( totals.testCases.passed, "test case" ) << - " with " << pluralise( totals.assertions.passed, "assertion" ) << "."; - } - } - }; - - INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter ) - -} // end namespace Catch - -namespace Catch { - NonCopyable::~NonCopyable() {} - IShared::~IShared() {} - StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {} - IContext::~IContext() {} - IResultCapture::~IResultCapture() {} - ITestCase::~ITestCase() {} - ITestCaseRegistry::~ITestCaseRegistry() {} - IRegistryHub::~IRegistryHub() {} - IMutableRegistryHub::~IMutableRegistryHub() {} - IExceptionTranslator::~IExceptionTranslator() {} - IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {} - IReporter::~IReporter() {} - IReporterFactory::~IReporterFactory() {} - IReporterRegistry::~IReporterRegistry() {} - IStreamingReporter::~IStreamingReporter() {} - AssertionStats::~AssertionStats() {} - SectionStats::~SectionStats() {} - TestCaseStats::~TestCaseStats() {} - TestGroupStats::~TestGroupStats() {} - TestRunStats::~TestRunStats() {} - CumulativeReporterBase::SectionNode::~SectionNode() {} - CumulativeReporterBase::~CumulativeReporterBase() {} - - StreamingReporterBase::~StreamingReporterBase() {} - ConsoleReporter::~ConsoleReporter() {} - CompactReporter::~CompactReporter() {} - IRunner::~IRunner() {} - IMutableContext::~IMutableContext() {} - IConfig::~IConfig() {} - XmlReporter::~XmlReporter() {} - JunitReporter::~JunitReporter() {} - TestRegistry::~TestRegistry() {} - FreeFunctionTestCase::~FreeFunctionTestCase() {} - IGeneratorInfo::~IGeneratorInfo() {} - IGeneratorsForTest::~IGeneratorsForTest() {} - TestSpec::Pattern::~Pattern() {} - TestSpec::NamePattern::~NamePattern() {} - TestSpec::TagPattern::~TagPattern() {} - TestSpec::ExcludedPattern::~ExcludedPattern() {} - - Matchers::Impl::StdString::Equals::~Equals() {} - Matchers::Impl::StdString::Contains::~Contains() {} - Matchers::Impl::StdString::StartsWith::~StartsWith() {} - Matchers::Impl::StdString::EndsWith::~EndsWith() {} - - void Config::dummy() {} -} - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif - -#endif - -#ifdef CATCH_CONFIG_MAIN -// #included from: internal/catch_default_main.hpp -#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED - -#ifndef __OBJC__ - -// Standard C/C++ main entry point -int main (int argc, char * const argv[]) { - return Catch::Session().run( argc, argv ); -} - -#else // __OBJC__ - -// Objective-C entry point -int main (int argc, char * const argv[]) { -#if !CATCH_ARC_ENABLED - NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; -#endif - - Catch::registerTestMethods(); - int result = Catch::Session().run( argc, (char* const*)argv ); - -#if !CATCH_ARC_ENABLED - [pool drain]; -#endif - - return result; -} - -#endif // __OBJC__ - -#endif - -#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED -# undef CLARA_CONFIG_MAIN -#endif - -////// - -// If this config identifier is defined then all CATCH macros are prefixed with CATCH_ -#ifdef CATCH_CONFIG_PREFIX_ALL - -#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" ) -#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" ) - -#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" ) -#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" ) -#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" ) - -#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" ) -#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" ) -#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" ) -#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" ) -#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" ) - -#define CATCH_CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" ) -#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" ) -#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" ) - -#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" ) -#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" ) - -#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) -#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg ) -#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) -#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) -#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) - -#ifdef CATCH_CONFIG_VARIADIC_MACROS - #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) - #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) - #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) - #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) - #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ ) - #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ ) -#else - #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) - #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) - #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) - #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) - #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg ) - #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg ) -#endif -#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) - -#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) -#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) - -#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) - -// "BDD-style" convenience wrappers -#ifdef CATCH_CONFIG_VARIADIC_MACROS -#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) -#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) -#else -#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags ) -#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) -#endif -#define CATCH_GIVEN( desc ) CATCH_SECTION( "Given: " desc, "" ) -#define CATCH_WHEN( desc ) CATCH_SECTION( " When: " desc, "" ) -#define CATCH_AND_WHEN( desc ) CATCH_SECTION( " And: " desc, "" ) -#define CATCH_THEN( desc ) CATCH_SECTION( " Then: " desc, "" ) -#define CATCH_AND_THEN( desc ) CATCH_SECTION( " And: " desc, "" ) - -// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required -#else - -#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" ) -#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" ) - -#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "REQUIRE_THROWS" ) -#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" ) -#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" ) - -#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" ) -#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" ) -#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" ) -#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" ) -#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" ) - -#define CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" ) -#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" ) -#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" ) - -#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" ) -#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" ) - -#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) -#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg ) -#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) -#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) -#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) - -#ifdef CATCH_CONFIG_VARIADIC_MACROS - #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) - #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) - #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) - #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) - #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ ) - #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ ) -#else - #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) - #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) - #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) - #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) - #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg ) - #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg ) -#endif -#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) - -#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) -#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) - -#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) - -#endif - -#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) - -// "BDD-style" convenience wrappers -#ifdef CATCH_CONFIG_VARIADIC_MACROS -#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) -#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) -#else -#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags ) -#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) -#endif -#define GIVEN( desc ) SECTION( " Given: " desc, "" ) -#define WHEN( desc ) SECTION( " When: " desc, "" ) -#define AND_WHEN( desc ) SECTION( "And when: " desc, "" ) -#define THEN( desc ) SECTION( " Then: " desc, "" ) -#define AND_THEN( desc ) SECTION( " And: " desc, "" ) - -using Catch::Detail::Approx; - -// #included from: internal/catch_reenable_warnings.h - -#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED - -#ifdef __clang__ -# ifdef __ICC // icpc defines the __clang__ macro -# pragma warning(pop) -# else -# pragma clang diagnostic pop -# endif -#elif defined __GNUC__ -# pragma GCC diagnostic pop -#endif - -#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED - diff --git a/tools/include/doctest.h b/tools/include/doctest.h deleted file mode 100644 index 695c271b..00000000 --- a/tools/include/doctest.h +++ /dev/null @@ -1,5696 +0,0 @@ -// ====================================================================== -// == DO NOT MODIFY THIS FILE BY HAND - IT IS AUTO GENERATED BY CMAKE! == -// ====================================================================== -// -// doctest.h - the lightest feature-rich C++ single-header testing framework for unit tests and TDD -// -// Copyright (c) 2016-2017 Viktor Kirilov -// -// Distributed under the MIT Software License -// See accompanying file LICENSE.txt or copy at -// https://opensource.org/licenses/MIT -// -// The documentation can be found at the library's page: -// https://github.com/onqtam/doctest/blob/master/doc/markdown/readme.md -// -// ================================================================================================= -// ================================================================================================= -// ================================================================================================= -// -// The library is heavily influenced by Catch - https://github.com/philsquared/Catch -// which uses the Boost Software License - Version 1.0 -// see here - https://github.com/philsquared/Catch/blob/master/LICENSE_1_0.txt -// -// The concept of subcases (sections in Catch) and expression decomposition are from there. -// Some parts of the code are taken directly: -// - stringification - the detection of "ostream& operator<<(ostream&, const T&)" and StringMaker<> -// - the Approx() helper class for floating point comparison -// - colors in the console -// - breaking into a debugger -// - signal / SEH handling -// - timer -// -// The expression decomposing templates are taken from lest - https://github.com/martinmoene/lest -// which uses the Boost Software License - Version 1.0 -// see here - https://github.com/martinmoene/lest/blob/master/LICENSE_1_0.txt -// -// The type list and the foreach algorithm on it for C++98 are taken from Loki -// - http://loki-lib.sourceforge.net/ -// - https://en.wikipedia.org/wiki/Loki_%28C%2B%2B%29 -// - https://github.com/snaewe/loki-lib -// which uses the MIT Software License -// -// ================================================================================================= -// ================================================================================================= -// ================================================================================================= - -// Suppress this globally (without push/pop) - there is no way to silence it in the -// expression decomposition macros _Pragma() in macros doesn't work for the c++ front-end of g++ -// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55578 -// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69543 -// Also the warning is completely worthless nowadays - http://stackoverflow.com/questions/14016993 -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic ignored "-Waggregate-return" -#endif - -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunknown-pragmas" -#pragma clang diagnostic ignored "-Wnon-virtual-dtor" -#pragma clang diagnostic ignored "-Wweak-vtables" -#pragma clang diagnostic ignored "-Wpadded" -#pragma clang diagnostic ignored "-Wdeprecated" -#pragma clang diagnostic ignored "-Wmissing-prototypes" -#pragma clang diagnostic ignored "-Wunused-local-typedef" -#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" -#pragma clang diagnostic ignored "-Wc++11-long-long" -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic push -#endif // > gcc 4.6 -#pragma GCC diagnostic ignored "-Wunknown-pragmas" -#pragma GCC diagnostic ignored "-Weffc++" -#pragma GCC diagnostic ignored "-Wstrict-overflow" -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" -#pragma GCC diagnostic ignored "-Wmissing-declarations" -#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" -#pragma GCC diagnostic ignored "-Winline" -#pragma GCC diagnostic ignored "-Wlong-long" -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" -#endif // > gcc 4.6 -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 7) -#pragma GCC diagnostic ignored "-Wunused-local-typedefs" -#endif // > gcc 4.7 -#if __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3) -#pragma GCC diagnostic ignored "-Wuseless-cast" -#endif // > gcc 5.3 -#endif // __GNUC__ - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4996) // The compiler encountered a deprecated declaration -#pragma warning(disable : 4706) // assignment within conditional expression -#pragma warning(disable : 4512) // 'class' : assignment operator could not be generated -#pragma warning(disable : 4127) // conditional expression is constant -#endif // _MSC_VER - -#ifndef DOCTEST_LIBRARY_INCLUDED -#define DOCTEST_LIBRARY_INCLUDED - -#define DOCTEST_VERSION_MAJOR 1 -#define DOCTEST_VERSION_MINOR 2 -#define DOCTEST_VERSION_PATCH 1 -#define DOCTEST_VERSION_STR "1.2.1" - -#define DOCTEST_VERSION \ - (DOCTEST_VERSION_MAJOR * 10000 + DOCTEST_VERSION_MINOR * 100 + DOCTEST_VERSION_PATCH) - -// ================================================================================================= -// == FEATURE DETECTION ============================================================================ -// ================================================================================================= - -#if __cplusplus >= 201103L -#ifndef DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#define DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#endif // DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#ifndef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#define DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#endif // DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#ifndef DOCTEST_CONFIG_WITH_NULLPTR -#define DOCTEST_CONFIG_WITH_NULLPTR -#endif // DOCTEST_CONFIG_WITH_NULLPTR -#ifndef DOCTEST_CONFIG_WITH_LONG_LONG -#define DOCTEST_CONFIG_WITH_LONG_LONG -#endif // DOCTEST_CONFIG_WITH_LONG_LONG -#ifndef DOCTEST_CONFIG_WITH_STATIC_ASSERT -#define DOCTEST_CONFIG_WITH_STATIC_ASSERT -#endif // DOCTEST_CONFIG_WITH_STATIC_ASSERT -#ifndef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#endif // __cplusplus >= 201103L - -#ifndef __has_feature -#define __has_feature(x) 0 -#endif // __has_feature - -// MSVC C++11 feature support table: https://msdn.microsoft.com/en-us/library/hh567368.aspx -// GCC C++11 feature support table: https://gcc.gnu.org/projects/cxx-status.html -// MSVC version table: -// MSVC++ 15.0 _MSC_VER == 1910 (Visual Studio 2017) -// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) -// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) -// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012) -// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) -// MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) -// MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005) - -// deleted functions - -#ifndef DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#if defined(_MSC_VER) && (_MSC_VER >= 1800) -#define DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#endif // _MSC_VER -#if defined(__clang__) && __has_feature(cxx_deleted_functions) -#define DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#endif // __clang__ -#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 4) || __GNUC__ > 4) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__) -#define DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#endif // __GNUC__ -#endif // DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS - -#if defined(DOCTEST_CONFIG_NO_DELETED_FUNCTIONS) && defined(DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS) -#undef DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS -#endif // DOCTEST_CONFIG_NO_DELETED_FUNCTIONS - -// rvalue references - -#ifndef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#if defined(_MSC_VER) && (_MSC_VER >= 1600) -#define DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#endif // _MSC_VER -#if defined(__clang__) && __has_feature(cxx_rvalue_references) -#define DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#endif // __clang__ -#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__) -#define DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#endif // __GNUC__ -#endif // DOCTEST_CONFIG_WITH_RVALUE_REFERENCES - -#if defined(DOCTEST_CONFIG_NO_RVALUE_REFERENCES) && defined(DOCTEST_CONFIG_WITH_RVALUE_REFERENCES) -#undef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -#endif // DOCTEST_CONFIG_NO_RVALUE_REFERENCES - -// nullptr - -#ifndef DOCTEST_CONFIG_WITH_NULLPTR -#if defined(__clang__) && __has_feature(cxx_nullptr) -#define DOCTEST_CONFIG_WITH_NULLPTR -#endif // __clang__ -#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __GNUC__ > 4) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__) -#define DOCTEST_CONFIG_WITH_NULLPTR -#endif // __GNUC__ -#if defined(_MSC_VER) && (_MSC_VER >= 1600) // MSVC 2010 -#define DOCTEST_CONFIG_WITH_NULLPTR -#endif // _MSC_VER -#endif // DOCTEST_CONFIG_WITH_NULLPTR - -#if defined(DOCTEST_CONFIG_NO_NULLPTR) && defined(DOCTEST_CONFIG_WITH_NULLPTR) -#undef DOCTEST_CONFIG_WITH_NULLPTR -#endif // DOCTEST_CONFIG_NO_NULLPTR - -// variadic macros - -#ifndef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#if defined(_MSC_VER) && _MSC_VER > 1400 && !defined(__EDGE__) -#define DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#endif // _MSC_VER -#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || __GNUC__ > 4) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__) -#define DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#endif // __GNUC__ and clang -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#if defined(DOCTEST_CONFIG_NO_VARIADIC_MACROS) && defined(DOCTEST_CONFIG_WITH_VARIADIC_MACROS) -#undef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#endif // DOCTEST_CONFIG_NO_VARIADIC_MACROS - -// long long - -#ifndef DOCTEST_CONFIG_WITH_LONG_LONG -#if defined(_MSC_VER) && (_MSC_VER >= 1400) -#define DOCTEST_CONFIG_WITH_LONG_LONG -#endif // _MSC_VER -#if(defined(__clang__) || \ - (defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 5) || __GNUC__ > 4))) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__) -#define DOCTEST_CONFIG_WITH_LONG_LONG -#endif // __GNUC__ and clang -#endif // DOCTEST_CONFIG_WITH_LONG_LONG - -#if defined(DOCTEST_CONFIG_NO_LONG_LONG) && defined(DOCTEST_CONFIG_WITH_LONG_LONG) -#undef DOCTEST_CONFIG_WITH_LONG_LONG -#endif // DOCTEST_CONFIG_NO_LONG_LONG - -// static_assert - -#ifndef DOCTEST_CONFIG_WITH_STATIC_ASSERT -#if defined(__clang__) && __has_feature(cxx_static_assert) -#define DOCTEST_CONFIG_WITH_STATIC_ASSERT -#endif // __clang__ -#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__) -#define DOCTEST_CONFIG_WITH_STATIC_ASSERT -#endif // __GNUC__ -#if defined(_MSC_VER) && (_MSC_VER >= 1600) // MSVC 2010 -#define DOCTEST_CONFIG_WITH_STATIC_ASSERT -#endif // _MSC_VER -#endif // DOCTEST_CONFIG_WITH_STATIC_ASSERT - -#if defined(DOCTEST_CONFIG_NO_STATIC_ASSERT) && defined(DOCTEST_CONFIG_WITH_STATIC_ASSERT) -#undef DOCTEST_CONFIG_WITH_STATIC_ASSERT -#endif // DOCTEST_CONFIG_NO_STATIC_ASSERT - -// other stuff... - -#if defined(DOCTEST_CONFIG_WITH_RVALUE_REFERENCES) || defined(DOCTEST_CONFIG_WITH_LONG_LONG) || \ - defined(DOCTEST_CONFIG_WITH_DELETED_FUNCTIONS) || defined(DOCTEST_CONFIG_WITH_NULLPTR) || \ - defined(DOCTEST_CONFIG_WITH_VARIADIC_MACROS) || defined(DOCTEST_CONFIG_WITH_STATIC_ASSERT) -#define DOCTEST_NO_CPP11_COMPAT -#endif // c++11 stuff - -#if defined(__clang__) && defined(DOCTEST_NO_CPP11_COMPAT) -#pragma clang diagnostic ignored "-Wc++98-compat" -#pragma clang diagnostic ignored "-Wc++98-compat-pedantic" -#endif // __clang__ && DOCTEST_NO_CPP11_COMPAT - -#if defined(_MSC_VER) && !defined(DOCTEST_CONFIG_WINDOWS_SEH) -#define DOCTEST_CONFIG_WINDOWS_SEH -#endif // _MSC_VER -#if defined(DOCTEST_CONFIG_NO_WINDOWS_SEH) && defined(DOCTEST_CONFIG_WINDOWS_SEH) -#undef DOCTEST_CONFIG_WINDOWS_SEH -#endif // DOCTEST_CONFIG_NO_WINDOWS_SEH - -#if !defined(_WIN32) && !defined(__QNX__) && !defined(DOCTEST_CONFIG_POSIX_SIGNALS) -#define DOCTEST_CONFIG_POSIX_SIGNALS -#endif // _WIN32 -#if defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS) && defined(DOCTEST_CONFIG_POSIX_SIGNALS) -#undef DOCTEST_CONFIG_POSIX_SIGNALS -#endif // DOCTEST_CONFIG_NO_POSIX_SIGNALS - -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS -#if defined(__GNUC__) && !defined(__EXCEPTIONS) -#define DOCTEST_CONFIG_NO_EXCEPTIONS -#endif // clang and gcc -// in MSVC _HAS_EXCEPTIONS is defined in a header instead of as a project define -// so we can't do the automatic detection for MSVC without including some header -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - -#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS -#define DOCTEST_CONFIG_NO_EXCEPTIONS -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS - -#if defined(DOCTEST_CONFIG_NO_EXCEPTIONS) && !defined(DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS) -#define DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS && !DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS - -#if defined(DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN) && !defined(DOCTEST_CONFIG_IMPLEMENT) -#define DOCTEST_CONFIG_IMPLEMENT -#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN - -#if defined _WIN32 || defined __CYGWIN__ -#ifdef __GNUC__ -#define DOCTEST_SYMBOL_EXPORT __attribute__((dllexport)) -#define DOCTEST_SYMBOL_IMPORT __attribute__((dllimport)) -#else // __GNUC__ -#define DOCTEST_SYMBOL_EXPORT __declspec(dllexport) -#define DOCTEST_SYMBOL_IMPORT __declspec(dllimport) -#endif // __GNUC__ -#else // _WIN32 -#define DOCTEST_SYMBOL_EXPORT __attribute__((visibility("default"))) -#define DOCTEST_SYMBOL_IMPORT -#endif // _WIN32 - -#ifdef DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL -#ifdef DOCTEST_CONFIG_IMPLEMENT -#define DOCTEST_INTERFACE DOCTEST_SYMBOL_EXPORT -#else // DOCTEST_CONFIG_IMPLEMENT -#define DOCTEST_INTERFACE DOCTEST_SYMBOL_IMPORT -#endif // DOCTEST_CONFIG_IMPLEMENT -#else // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL -#define DOCTEST_INTERFACE -#endif // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL - -#ifdef _MSC_VER -#define DOCTEST_NOINLINE __declspec(noinline) -#else // _MSC_VER -#define DOCTEST_NOINLINE __attribute__((noinline)) -#endif // _MSC_VER - -#ifndef DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK -#define DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK 5 -#endif // DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK - -// ================================================================================================= -// == FEATURE DETECTION END ======================================================================== -// ================================================================================================= - -// internal macros for string concatenation and anonymous variable name generation -#define DOCTEST_CAT_IMPL(s1, s2) s1##s2 -#define DOCTEST_CAT(s1, s2) DOCTEST_CAT_IMPL(s1, s2) -#ifdef __COUNTER__ // not standard and may be missing for some compilers -#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __COUNTER__) -#else // __COUNTER__ -#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __LINE__) -#endif // __COUNTER__ - -// macro for making a string out of an identifier -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TOSTR_IMPL(...) #__VA_ARGS__ -#define DOCTEST_TOSTR(...) DOCTEST_TOSTR_IMPL(__VA_ARGS__) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TOSTR_IMPL(x) #x -#define DOCTEST_TOSTR(x) DOCTEST_TOSTR_IMPL(x) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -// for concatenating literals and making the result a string -#define DOCTEST_STR_CONCAT_TOSTR(s1, s2) DOCTEST_TOSTR(s1) DOCTEST_TOSTR(s2) - -// counts the number of elements in a C string -#define DOCTEST_COUNTOF(x) (sizeof(x) / sizeof(x[0])) - -#ifndef DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE -#define DOCTEST_REF_WRAP(x) x& -#else // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE -#define DOCTEST_REF_WRAP(x) x -#endif // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE - -// not using __APPLE__ because... this is how Catch does it -#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) -#define DOCTEST_PLATFORM_MAC -#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) -#define DOCTEST_PLATFORM_IPHONE -#elif defined(_WIN32) || defined(_MSC_VER) -#define DOCTEST_PLATFORM_WINDOWS -#else -#define DOCTEST_PLATFORM_LINUX -#endif - -#if defined(__clang__) -#define DOCTEST_GLOBAL_NO_WARNINGS(var) \ - _Pragma("clang diagnostic push") \ - _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") static int var -#define DOCTEST_GLOBAL_NO_WARNINGS_END() _Pragma("clang diagnostic pop") -#elif defined(__GNUC__) -#define DOCTEST_GLOBAL_NO_WARNINGS(var) static int var __attribute__((unused)) -#define DOCTEST_GLOBAL_NO_WARNINGS_END() -#else // MSVC / other -#define DOCTEST_GLOBAL_NO_WARNINGS(var) static int var -#define DOCTEST_GLOBAL_NO_WARNINGS_END() -#endif // MSVC / other - -// should probably take a look at https://github.com/scottt/debugbreak -#ifdef DOCTEST_PLATFORM_MAC -#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) -#elif defined(_MSC_VER) -#define DOCTEST_BREAK_INTO_DEBUGGER() __debugbreak() -#elif defined(__MINGW32__) -extern "C" __declspec(dllimport) void __stdcall DebugBreak(); -#define DOCTEST_BREAK_INTO_DEBUGGER() ::DebugBreak() -#else // linux -#define DOCTEST_BREAK_INTO_DEBUGGER() ((void)0) -#endif // linux - -#ifdef __clang__ -// to detect if libc++ is being used with clang (the _LIBCPP_VERSION identifier) -#include -#endif // __clang__ - -#ifdef _LIBCPP_VERSION -// not forward declaring ostream for libc++ because I had some problems (inline namespaces vs c++98) -// so the header is used - also it is very light and doesn't drag a ton of stuff -#include -#else // _LIBCPP_VERSION -#ifndef DOCTEST_CONFIG_USE_IOSFWD -namespace std -{ -template -struct char_traits; -template <> -struct char_traits; -template -class basic_ostream; -typedef basic_ostream > ostream; -} // namespace std -#else // DOCTEST_CONFIG_USE_IOSFWD -#include -#endif // DOCTEST_CONFIG_USE_IOSFWD -#endif // _LIBCPP_VERSION - -// static assert macro - because of the c++98 support requires that the message is an -// identifier (no spaces and not a C string) - example without quotes: I_am_a_message -// taken from here: http://stackoverflow.com/a/1980156/3162383 -#ifdef DOCTEST_CONFIG_WITH_STATIC_ASSERT -#define DOCTEST_STATIC_ASSERT(expression, message) static_assert(expression, #message) -#else // DOCTEST_CONFIG_WITH_STATIC_ASSERT -#define DOCTEST_STATIC_ASSERT(expression, message) \ - struct DOCTEST_CAT(__static_assertion_at_line_, __LINE__) \ - { \ - doctest::detail::static_assert_impl::StaticAssertion((expression))> \ - DOCTEST_CAT(DOCTEST_CAT(DOCTEST_CAT(STATIC_ASSERTION_FAILED_AT_LINE_, __LINE__), \ - _), \ - message); \ - }; \ - typedef doctest::detail::static_assert_impl::StaticAssertionTest( \ - sizeof(DOCTEST_CAT(__static_assertion_at_line_, __LINE__)))> \ - DOCTEST_CAT(__static_assertion_test_at_line_, __LINE__) -#endif // DOCTEST_CONFIG_WITH_STATIC_ASSERT - -#ifdef DOCTEST_CONFIG_WITH_NULLPTR -#ifdef _LIBCPP_VERSION -#include -#else // _LIBCPP_VERSION -namespace std -{ typedef decltype(nullptr) nullptr_t; } -#endif // _LIBCPP_VERSION -#endif // DOCTEST_CONFIG_WITH_NULLPTR - -#ifndef DOCTEST_CONFIG_DISABLE -namespace doctest -{ -namespace detail -{ - struct TestSuite - { - const char* m_test_suite; - const char* m_description; - bool m_skip; - bool m_may_fail; - bool m_should_fail; - int m_expected_failures; - double m_timeout; - - TestSuite& operator*(const char* in) { - m_test_suite = in; - // clear state - m_description = 0; - m_skip = false; - m_may_fail = false; - m_should_fail = false; - m_expected_failures = 0; - m_timeout = 0; - return *this; - } - - template - TestSuite& operator*(const T& in) { - in.fill(*this); - return *this; - } - }; -} // namespace detail -} // namespace doctest - -// in a separate namespace outside of doctest because the DOCTEST_TEST_SUITE macro -// introduces an anonymous namespace in which getCurrentTestSuite gets overridden -namespace doctest_detail_test_suite_ns -{ -DOCTEST_INTERFACE doctest::detail::TestSuite& getCurrentTestSuite(); -} // namespace doctest_detail_test_suite_ns - -#endif // DOCTEST_CONFIG_DISABLE - -namespace doctest -{ -// A 24 byte string class (can be as small as 17 for x64 and 13 for x86) that can hold strings with length -// of up to 23 chars on the stack before going on the heap - the last byte of the buffer is used for: -// - "is small" bit - the highest bit - if "0" then it is small - otherwise its "1" (128) -// - if small - capacity left before going on the heap - using the lowest 5 bits -// - if small - 2 bits are left unused - the second and third highest ones -// - if small - acts as a null terminator if strlen() is 23 (24 including the null terminator) -// and the "is small" bit remains "0" ("as well as the capacity left") so its OK -// Idea taken from this lecture about the string implementation of facebook/folly - fbstring -// https://www.youtube.com/watch?v=kPR8h4-qZdk -// TODO: -// - optimizations - like not deleting memory unnecessarily in operator= and etc. -// - resize/reserve/clear -// - substr -// - replace -// - back/front -// - iterator stuff -// - find & friends -// - push_back/pop_back -// - assign/insert/erase -// - relational operators as free functions - taking const char* as one of the params -class DOCTEST_INTERFACE String -{ - static const unsigned len = 24; //!OCLINT avoid private static members - static const unsigned last = len - 1; //!OCLINT avoid private static members - - struct view // len should be more than sizeof(view) - because of the final byte for flags - { - char* ptr; - unsigned size; - unsigned capacity; - }; - - union - { - char buf[len]; - view data; - }; - - void copy(const String& other); - - void setOnHeap() { *reinterpret_cast(&buf[last]) = 128; } - void setLast(unsigned in = last) { buf[last] = char(in); } - -public: - String() { - buf[0] = '\0'; - setLast(); - } - - String(const char* in); - - String(const String& other) { copy(other); } - - ~String() { - if(!isOnStack()) - delete[] data.ptr; - } - - // GCC 4.9/5/6 report Wstrict-overflow when optimizations are ON and it got inlined in the vector class somewhere... - // see commit 574ef95f0cd379118be5011704664e4b5351f1e0 and build https://travis-ci.org/onqtam/doctest/builds/230671611 - DOCTEST_NOINLINE String& operator=(const String& other) { - if(!isOnStack()) - delete[] data.ptr; - - copy(other); - - return *this; - } - String& operator+=(const String& other); - - String operator+(const String& other) const { return String(*this) += other; } - -#ifdef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES - String(String&& other); - String& operator=(String&& other); -#endif // DOCTEST_CONFIG_WITH_RVALUE_REFERENCES - - bool isOnStack() const { return (buf[last] & 128) == 0; } - - char operator[](unsigned i) const { return const_cast(this)->operator[](i); } // NOLINT - char& operator[](unsigned i) { - if(isOnStack()) - return reinterpret_cast(buf)[i]; - return data.ptr[i]; - } - - const char* c_str() const { return const_cast(this)->c_str(); } // NOLINT - char* c_str() { - if(isOnStack()) - return reinterpret_cast(buf); - return data.ptr; - } - - unsigned size() const { - if(isOnStack()) - return last - (unsigned(buf[last]) & 31); // using "last" would work only if "len" is 32 - return data.size; - } - - unsigned capacity() const { - if(isOnStack()) - return len; - return data.capacity; - } - - int compare(const char* other, bool no_case = false) const; - int compare(const String& other, bool no_case = false) const; -}; - -// clang-format off -inline bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; } -inline bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; } -inline bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; } -inline bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; } -inline bool operator<=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) < 0 : true; } -inline bool operator>=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) > 0 : true; } -// clang-format on - -DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& stream, const String& in); - -namespace detail -{ -#ifndef DOCTEST_CONFIG_WITH_STATIC_ASSERT - namespace static_assert_impl - { - template - struct StaticAssertion; - - template <> - struct StaticAssertion - {}; - - template - struct StaticAssertionTest - {}; - } // namespace static_assert_impl -#endif // DOCTEST_CONFIG_WITH_STATIC_ASSERT - - namespace traits - { - template - struct remove_const - { typedef T type; }; - - template - struct remove_const - { typedef T type; }; - - template - struct remove_volatile - { typedef T type; }; - - template - struct remove_volatile - { typedef T type; }; - - template - struct remove_cv - { typedef typename remove_volatile::type>::type type; }; - - template - struct is_pointer_helper - { static const bool value = false; }; - - template - struct is_pointer_helper - // cppcheck-suppress unusedStructMember - { static const bool value = true; }; - - template - struct is_pointer - // cppcheck-suppress unusedStructMember - { static const bool value = is_pointer_helper::type>::value; }; - - template - struct enable_if - {}; - - template - struct enable_if - { typedef TYPE type; }; - - template - struct remove_reference - { typedef T type; }; - - template - struct remove_reference - { typedef T type; }; - - template - class is_constructible_impl - { - private: - template - static bool test(typename enable_if< //!OCLINT avoid private static members - sizeof(C_T) == - sizeof(C_T(static_cast( - *static_cast::type*>( - 0))))>::type*); - - template - static int test(...); //!OCLINT avoid private static members - - public: - static const bool value = sizeof(test(0)) == sizeof(bool); - }; - - template - class is_constructible_impl - { - private: - template - static C_T testFun(C_T); //!OCLINT avoid private static members - - template - static bool test(typename enable_if< //!OCLINT avoid private static members - sizeof(C_T) == sizeof(testFun(C_T()))>::type*); - - template - static int test(...); //!OCLINT avoid private static members - - public: - static const bool value = sizeof(test(0)) == sizeof(bool); - }; - -// is_constructible<> taken from here: http://stackoverflow.com/a/40443701/3162383 -// for GCC/Clang gives the same results as std::is_constructible<> - see here: https://wandbox.org/permlink/bNWr7Ii2fuz4Vf7A -// modifications: -// - reworked to support only 1 argument (mainly because of MSVC...) -// - removed pointer support -// MSVC support: -// - for versions before 2012 read the CAUTION comment below -// currently intended for use only in the Approx() helper for strong typedefs of double - see issue #62 -#ifndef _MSC_VER - template - class is_constructible - { - public: - static const bool value = is_pointer::type>::value ? - false : - is_constructible_impl::value; - }; -#elif defined(_MSC_VER) && (_MSC_VER >= 1700) - template - struct is_constructible - { static const bool value = __is_constructible(T, AT_1); }; -#elif defined(_MSC_VER) - // !!! USE WITH CAUTION !!! - // will always return false - unable to implement this for versions of MSVC older than 2012 for now... - template - struct is_constructible - { static const bool value = false; }; -#endif // _MSC_VER - } // namespace traits - - template - struct deferred_false - // cppcheck-suppress unusedStructMember - { static const bool value = false; }; - - // to silence the warning "-Wzero-as-null-pointer-constant" only for gcc 5 for the Approx template ctor - pragmas don't work for it... - inline void* getNull() { return 0; } - - namespace has_insertion_operator_impl - { - typedef char no; - typedef char yes[2]; - - struct any_t - { - template - // cppcheck-suppress noExplicitConstructor - any_t(const DOCTEST_REF_WRAP(T)); - }; - - yes& testStreamable(std::ostream&); - no testStreamable(no); - - no operator<<(const std::ostream&, const any_t&); - - template - struct has_insertion_operator - { - static std::ostream& s; - static const DOCTEST_REF_WRAP(T) t; - static const bool value = sizeof(testStreamable(s << t)) == sizeof(yes); - }; - } // namespace has_insertion_operator_impl - - template - struct has_insertion_operator : has_insertion_operator_impl::has_insertion_operator - {}; - - DOCTEST_INTERFACE void my_memcpy(void* dest, const void* src, unsigned num); - DOCTEST_INTERFACE unsigned my_strlen(const char* in); - - DOCTEST_INTERFACE std::ostream* createStream(); - DOCTEST_INTERFACE String getStreamResult(std::ostream*); - DOCTEST_INTERFACE void freeStream(std::ostream*); - - template - struct StringMakerBase - { - template - static String convert(const DOCTEST_REF_WRAP(T)) { - return "{?}"; - } - }; - - template <> - struct StringMakerBase - { - template - static String convert(const DOCTEST_REF_WRAP(T) in) { - std::ostream* stream = createStream(); - *stream << in; - String result = getStreamResult(stream); - freeStream(stream); - return result; - } - }; - - DOCTEST_INTERFACE String rawMemoryToString(const void* object, unsigned size); - - template - String rawMemoryToString(const DOCTEST_REF_WRAP(T) object) { - return rawMemoryToString(&object, sizeof(object)); - } - - class NullType - {}; - - template - struct Typelist - { - typedef T Head; - typedef U Tail; - }; - - // type of recursive function - template - struct ForEachType; - - // Recursion rule - template - struct ForEachType, Callable> : public ForEachType - { - enum - { - value = 1 + ForEachType::value - }; - - explicit ForEachType(Callable& callable) - : ForEachType(callable) { -#if defined(_MSC_VER) && _MSC_VER <= 1900 - callable.operator()(); -#else // _MSC_VER - callable.template operator()(); -#endif // _MSC_VER - } - }; - - // Recursion end - template - struct ForEachType, Callable> - { - public: - enum - { - value = 0 - }; - - explicit ForEachType(Callable& callable) { -#if defined(_MSC_VER) && _MSC_VER <= 1900 - callable.operator()(); -#else // _MSC_VER - callable.template operator()(); -#endif // _MSC_VER - } - }; - - template - const char* type_to_string() { - return "<>"; - } -} // namespace detail - -template -struct Types -{ -private: - typedef typename Types::Result TailResult; - -public: - typedef detail::Typelist Result; -}; - -template <> -struct Types<> -{ typedef detail::NullType Result; }; - -template -struct StringMaker : detail::StringMakerBase::value> -{}; - -template -struct StringMaker -{ - template - static String convert(U* p) { - if(p) - return detail::rawMemoryToString(p); - return "NULL"; - } -}; - -template -struct StringMaker -{ - static String convert(R C::*p) { - if(p) - return detail::rawMemoryToString(p); - return "NULL"; - } -}; - -template -String toString(const DOCTEST_REF_WRAP(T) value) { - return StringMaker::convert(value); -} - -#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -DOCTEST_INTERFACE String toString(char* in); -DOCTEST_INTERFACE String toString(const char* in); -#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -DOCTEST_INTERFACE String toString(bool in); -DOCTEST_INTERFACE String toString(float in); -DOCTEST_INTERFACE String toString(double in); -DOCTEST_INTERFACE String toString(double long in); - -DOCTEST_INTERFACE String toString(char in); -DOCTEST_INTERFACE String toString(char signed in); -DOCTEST_INTERFACE String toString(char unsigned in); -DOCTEST_INTERFACE String toString(int short in); -DOCTEST_INTERFACE String toString(int short unsigned in); -DOCTEST_INTERFACE String toString(int in); -DOCTEST_INTERFACE String toString(int unsigned in); -DOCTEST_INTERFACE String toString(int long in); -DOCTEST_INTERFACE String toString(int long unsigned in); - -#ifdef DOCTEST_CONFIG_WITH_LONG_LONG -DOCTEST_INTERFACE String toString(int long long in); -DOCTEST_INTERFACE String toString(int long long unsigned in); -#endif // DOCTEST_CONFIG_WITH_LONG_LONG - -#ifdef DOCTEST_CONFIG_WITH_NULLPTR -DOCTEST_INTERFACE String toString(std::nullptr_t in); -#endif // DOCTEST_CONFIG_WITH_NULLPTR - -class DOCTEST_INTERFACE Approx -{ -public: - explicit Approx(double value); - - Approx operator()(double value) const { - Approx approx(value); - approx.epsilon(m_epsilon); - approx.scale(m_scale); - return approx; - } - - template - explicit Approx(const T& value, - typename detail::traits::enable_if< - detail::traits::is_constructible::value>::type* = - static_cast(detail::getNull())) { - *this = Approx(static_cast(value)); - } - - // clang-format off - // overloads for double - the first one is necessary as it is in the implementation part of doctest - // as for the others - keeping them for potentially faster compile times - DOCTEST_INTERFACE friend bool operator==(double lhs, Approx const& rhs); - friend bool operator==(Approx const& lhs, double rhs) { return operator==(rhs, lhs); } - friend bool operator!=(double lhs, Approx const& rhs) { return !operator==(lhs, rhs); } - friend bool operator!=(Approx const& lhs, double rhs) { return !operator==(rhs, lhs); } - friend bool operator<=(double lhs, Approx const& rhs) { return lhs < rhs.m_value || lhs == rhs; } - friend bool operator<=(Approx const& lhs, double rhs) { return lhs.m_value < rhs || lhs == rhs; } - friend bool operator>=(double lhs, Approx const& rhs) { return lhs > rhs.m_value || lhs == rhs; } - friend bool operator>=(Approx const& lhs, double rhs) { return lhs.m_value > rhs || lhs == rhs; } - friend bool operator< (double lhs, Approx const& rhs) { return lhs < rhs.m_value && lhs != rhs; } - friend bool operator< (Approx const& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; } - friend bool operator> (double lhs, Approx const& rhs) { return lhs > rhs.m_value && lhs != rhs; } - friend bool operator> (Approx const& lhs, double rhs) { return lhs.m_value > rhs && lhs != rhs; } - -#define DOCTEST_APPROX_PREFIX \ - template friend typename detail::traits::enable_if::value, bool>::type - - DOCTEST_APPROX_PREFIX operator==(const T& lhs, const Approx& rhs) { return operator==(double(lhs), rhs); } - DOCTEST_APPROX_PREFIX operator==(const Approx& lhs, const T& rhs) { return operator==(rhs, lhs); } - DOCTEST_APPROX_PREFIX operator!=(const T& lhs, const Approx& rhs) { return !operator==(lhs, rhs); } - DOCTEST_APPROX_PREFIX operator!=(const Approx& lhs, const T& rhs) { return !operator==(rhs, lhs); } - DOCTEST_APPROX_PREFIX operator<=(const T& lhs, const Approx& rhs) { return double(lhs) < rhs.m_value || lhs == rhs; } - DOCTEST_APPROX_PREFIX operator<=(const Approx& lhs, const T& rhs) { return lhs.m_value < double(rhs) || lhs == rhs; } - DOCTEST_APPROX_PREFIX operator>=(const T& lhs, const Approx& rhs) { return double(lhs) > rhs.m_value || lhs == rhs; } - DOCTEST_APPROX_PREFIX operator>=(const Approx& lhs, const T& rhs) { return lhs.m_value > double(rhs) || lhs == rhs; } - DOCTEST_APPROX_PREFIX operator< (const T& lhs, const Approx& rhs) { return double(lhs) < rhs.m_value && lhs != rhs; } - DOCTEST_APPROX_PREFIX operator< (const Approx& lhs, const T& rhs) { return lhs.m_value < double(rhs) && lhs != rhs; } - DOCTEST_APPROX_PREFIX operator> (const T& lhs, const Approx& rhs) { return double(lhs) > rhs.m_value && lhs != rhs; } - DOCTEST_APPROX_PREFIX operator> (const Approx& lhs, const T& rhs) { return lhs.m_value > double(rhs) && lhs != rhs; } -#undef DOCTEST_APPROX_PREFIX - // clang-format on - - Approx& epsilon(double newEpsilon) { - m_epsilon = (newEpsilon); - return *this; - } - - template - typename detail::traits::enable_if::value, - Approx&>::type - epsilon(const T& newEpsilon) { - m_epsilon = static_cast(newEpsilon); - return *this; - } - - Approx& scale(double newScale) { - m_scale = (newScale); - return *this; - } - - template - typename detail::traits::enable_if::value, - Approx&>::type - scale(const T& newScale) { - m_scale = static_cast(newScale); - return *this; - } - - String toString() const; - -private: - double m_epsilon; - double m_scale; - double m_value; -}; - -template <> -inline String toString(const DOCTEST_REF_WRAP(Approx) value) { - return value.toString(); -} - -#if !defined(DOCTEST_CONFIG_DISABLE) - -namespace detail -{ - // the function type this library works with - typedef void (*funcType)(); - - namespace assertType - { - enum Enum - { - // macro traits - - is_warn = 1, - is_check = 2, - is_require = 4, - - is_throws = 8, - is_throws_as = 16, - is_nothrow = 32, - - is_fast = 64, // not checked anywhere - used just to distinguish the types - is_false = 128, - is_unary = 256, - - is_eq = 512, - is_ne = 1024, - - is_lt = 2048, - is_gt = 4096, - - is_ge = 8192, - is_le = 16384, - - // macro types - - DT_WARN = is_warn, - DT_CHECK = is_check, - DT_REQUIRE = is_require, - - DT_WARN_FALSE = is_false | is_warn, - DT_CHECK_FALSE = is_false | is_check, - DT_REQUIRE_FALSE = is_false | is_require, - - DT_WARN_THROWS = is_throws | is_warn, - DT_CHECK_THROWS = is_throws | is_check, - DT_REQUIRE_THROWS = is_throws | is_require, - - DT_WARN_THROWS_AS = is_throws_as | is_warn, - DT_CHECK_THROWS_AS = is_throws_as | is_check, - DT_REQUIRE_THROWS_AS = is_throws_as | is_require, - - DT_WARN_NOTHROW = is_nothrow | is_warn, - DT_CHECK_NOTHROW = is_nothrow | is_check, - DT_REQUIRE_NOTHROW = is_nothrow | is_require, - - DT_WARN_EQ = is_eq | is_warn, - DT_CHECK_EQ = is_eq | is_check, - DT_REQUIRE_EQ = is_eq | is_require, - - DT_WARN_NE = is_ne | is_warn, - DT_CHECK_NE = is_ne | is_check, - DT_REQUIRE_NE = is_ne | is_require, - - DT_WARN_GT = is_gt | is_warn, - DT_CHECK_GT = is_gt | is_check, - DT_REQUIRE_GT = is_gt | is_require, - - DT_WARN_LT = is_lt | is_warn, - DT_CHECK_LT = is_lt | is_check, - DT_REQUIRE_LT = is_lt | is_require, - - DT_WARN_GE = is_ge | is_warn, - DT_CHECK_GE = is_ge | is_check, - DT_REQUIRE_GE = is_ge | is_require, - - DT_WARN_LE = is_le | is_warn, - DT_CHECK_LE = is_le | is_check, - DT_REQUIRE_LE = is_le | is_require, - - DT_WARN_UNARY = is_unary | is_warn, - DT_CHECK_UNARY = is_unary | is_check, - DT_REQUIRE_UNARY = is_unary | is_require, - - DT_WARN_UNARY_FALSE = is_false | is_unary | is_warn, - DT_CHECK_UNARY_FALSE = is_false | is_unary | is_check, - DT_REQUIRE_UNARY_FALSE = is_false | is_unary | is_require, - - DT_FAST_WARN_EQ = is_fast | is_eq | is_warn, - DT_FAST_CHECK_EQ = is_fast | is_eq | is_check, - DT_FAST_REQUIRE_EQ = is_fast | is_eq | is_require, - - DT_FAST_WARN_NE = is_fast | is_ne | is_warn, - DT_FAST_CHECK_NE = is_fast | is_ne | is_check, - DT_FAST_REQUIRE_NE = is_fast | is_ne | is_require, - - DT_FAST_WARN_GT = is_fast | is_gt | is_warn, - DT_FAST_CHECK_GT = is_fast | is_gt | is_check, - DT_FAST_REQUIRE_GT = is_fast | is_gt | is_require, - - DT_FAST_WARN_LT = is_fast | is_lt | is_warn, - DT_FAST_CHECK_LT = is_fast | is_lt | is_check, - DT_FAST_REQUIRE_LT = is_fast | is_lt | is_require, - - DT_FAST_WARN_GE = is_fast | is_ge | is_warn, - DT_FAST_CHECK_GE = is_fast | is_ge | is_check, - DT_FAST_REQUIRE_GE = is_fast | is_ge | is_require, - - DT_FAST_WARN_LE = is_fast | is_le | is_warn, - DT_FAST_CHECK_LE = is_fast | is_le | is_check, - DT_FAST_REQUIRE_LE = is_fast | is_le | is_require, - - DT_FAST_WARN_UNARY = is_fast | is_unary | is_warn, - DT_FAST_CHECK_UNARY = is_fast | is_unary | is_check, - DT_FAST_REQUIRE_UNARY = is_fast | is_unary | is_require, - - DT_FAST_WARN_UNARY_FALSE = is_fast | is_false | is_unary | is_warn, - DT_FAST_CHECK_UNARY_FALSE = is_fast | is_false | is_unary | is_check, - DT_FAST_REQUIRE_UNARY_FALSE = is_fast | is_false | is_unary | is_require - }; - } // namespace assertType - - DOCTEST_INTERFACE const char* getAssertString(assertType::Enum val); - - // clang-format off - template struct decay_array { typedef T type; }; - template struct decay_array { typedef T* type; }; - template struct decay_array { typedef T* type; }; - - template struct not_char_pointer { enum { value = 1 }; }; - template<> struct not_char_pointer { enum { value = 0 }; }; - template<> struct not_char_pointer { enum { value = 0 }; }; - - template struct can_use_op : not_char_pointer::type> {}; - // clang-format on - - struct TestFailureException - {}; - - DOCTEST_INTERFACE bool checkIfShouldThrow(assertType::Enum assert_type); - DOCTEST_INTERFACE void fastAssertThrowIfFlagSet(int flags); - DOCTEST_INTERFACE void throwException(); - - struct TestAccessibleContextState - { - bool no_throw; // to skip exceptions-related assertion macros - bool success; // include successful assertions in output - }; - - struct ContextState; - - DOCTEST_INTERFACE TestAccessibleContextState* getTestsContextState(); - - struct DOCTEST_INTERFACE SubcaseSignature - { - const char* m_name; - const char* m_file; - int m_line; - - SubcaseSignature(const char* name, const char* file, int line) - : m_name(name) - , m_file(file) - , m_line(line) {} - - bool operator<(const SubcaseSignature& other) const; - }; - - // cppcheck-suppress copyCtorAndEqOperator - struct DOCTEST_INTERFACE Subcase - { - SubcaseSignature m_signature; - bool m_entered; - - Subcase(const char* name, const char* file, int line); - Subcase(const Subcase& other); - ~Subcase(); - - operator bool() const { return m_entered; } - }; - - template - String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op, - const DOCTEST_REF_WRAP(R) rhs) { - return toString(lhs) + op + toString(rhs); - } - - struct DOCTEST_INTERFACE Result - { - bool m_passed; - String m_decomposition; - - ~Result(); - - DOCTEST_NOINLINE Result(bool passed = false, const String& decomposition = String()) - : m_passed(passed) - , m_decomposition(decomposition) {} - - DOCTEST_NOINLINE Result(const Result& other) - : m_passed(other.m_passed) - , m_decomposition(other.m_decomposition) {} - - Result& operator=(const Result& other); - - operator bool() { return !m_passed; } - - // clang-format off - // forbidding some expressions based on this table: http://en.cppreference.com/w/cpp/language/operator_precedence - template Result& operator& (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator^ (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator| (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator&& (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator|| (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator== (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator!= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator< (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator> (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator<= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator>= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator+= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator-= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator*= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator/= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator%= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator<<=(const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator>>=(const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator&= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator^= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - template Result& operator|= (const R&) { DOCTEST_STATIC_ASSERT(deferred_false::value, Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); return *this; } - // clang-format on - }; - -#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION - -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wsign-conversion" -#pragma clang diagnostic ignored "-Wsign-compare" -//#pragma clang diagnostic ignored "-Wdouble-promotion" -//#pragma clang diagnostic ignored "-Wconversion" -//#pragma clang diagnostic ignored "-Wfloat-equal" -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic push -#endif // > gcc 4.6 -#pragma GCC diagnostic ignored "-Wsign-conversion" -#pragma GCC diagnostic ignored "-Wsign-compare" -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5) -//#pragma GCC diagnostic ignored "-Wdouble-promotion" -#endif // > gcc 4.5 -//#pragma GCC diagnostic ignored "-Wconversion" -//#pragma GCC diagnostic ignored "-Wfloat-equal" -#endif // __GNUC__ - -#ifdef _MSC_VER -#pragma warning(push) -// http://stackoverflow.com/questions/39479163 what's the difference between C4018 and C4389 -#pragma warning(disable : 4389) // 'operator' : signed/unsigned mismatch -#pragma warning(disable : 4018) // 'expression' : signed/unsigned mismatch -//#pragma warning(disable : 4805) // 'operation' : unsafe mix of type 'type' and type 'type' in operation -#endif // _MSC_VER - -#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION - -// clang-format off -#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -#define DOCTEST_COMPARISON_RETURN_TYPE bool -#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -#define DOCTEST_COMPARISON_RETURN_TYPE typename traits::enable_if::value || can_use_op::value, bool>::type - inline bool eq(const char* lhs, const char* rhs) { return String(lhs) == String(rhs); } - inline bool ne(const char* lhs, const char* rhs) { return String(lhs) != String(rhs); } - inline bool lt(const char* lhs, const char* rhs) { return String(lhs) < String(rhs); } - inline bool gt(const char* lhs, const char* rhs) { return String(lhs) > String(rhs); } - inline bool le(const char* lhs, const char* rhs) { return String(lhs) <= String(rhs); } - inline bool ge(const char* lhs, const char* rhs) { return String(lhs) >= String(rhs); } -#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING - - template DOCTEST_COMPARISON_RETURN_TYPE eq(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs == rhs; } - template DOCTEST_COMPARISON_RETURN_TYPE ne(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs != rhs; } - template DOCTEST_COMPARISON_RETURN_TYPE lt(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs < rhs; } - template DOCTEST_COMPARISON_RETURN_TYPE gt(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs > rhs; } - template DOCTEST_COMPARISON_RETURN_TYPE le(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs <= rhs; } - template DOCTEST_COMPARISON_RETURN_TYPE ge(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs >= rhs; } -// clang-format on - -#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -#define DOCTEST_CMP_EQ(l, r) l == r -#define DOCTEST_CMP_NE(l, r) l != r -#define DOCTEST_CMP_GT(l, r) l > r -#define DOCTEST_CMP_LT(l, r) l < r -#define DOCTEST_CMP_GE(l, r) l >= r -#define DOCTEST_CMP_LE(l, r) l <= r -#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -#define DOCTEST_CMP_EQ(l, r) eq(l, r) -#define DOCTEST_CMP_NE(l, r) ne(l, r) -#define DOCTEST_CMP_GT(l, r) gt(l, r) -#define DOCTEST_CMP_LT(l, r) lt(l, r) -#define DOCTEST_CMP_GE(l, r) ge(l, r) -#define DOCTEST_CMP_LE(l, r) le(l, r) -#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING - -#define DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(op, op_str, op_macro) \ - template \ - DOCTEST_NOINLINE Result operator op(const DOCTEST_REF_WRAP(R) rhs) { \ - bool res = op_macro(lhs, rhs); \ - if(m_assert_type & assertType::is_false) \ - res = !res; \ - if(!res || doctest::detail::getTestsContextState()->success) \ - return Result(res, stringifyBinaryExpr(lhs, op_str, rhs)); \ - return Result(res); \ - } - -#define DOCTEST_FORBIT_EXPRESSION(op) \ - template \ - Expression_lhs& operator op(const R&) { \ - DOCTEST_STATIC_ASSERT(deferred_false::value, \ - Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison); \ - return *this; \ - } - - template - // cppcheck-suppress copyCtorAndEqOperator - struct Expression_lhs - { - L lhs; - assertType::Enum m_assert_type; - - explicit Expression_lhs(L in, assertType::Enum assert_type) - : lhs(in) - , m_assert_type(assert_type) {} - - Expression_lhs(const Expression_lhs& other) - : lhs(other.lhs) {} - - DOCTEST_NOINLINE operator Result() { - bool res = !!lhs; - if(m_assert_type & assertType::is_false) //!OCLINT bitwise operator in conditional - res = !res; - - if(!res || getTestsContextState()->success) - return Result(res, toString(lhs)); - return Result(res); - } - - // clang-format off - DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(==, " == ", DOCTEST_CMP_EQ) //!OCLINT bitwise operator in conditional - DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(!=, " != ", DOCTEST_CMP_NE) //!OCLINT bitwise operator in conditional - DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>, " > ", DOCTEST_CMP_GT) //!OCLINT bitwise operator in conditional - DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<, " < ", DOCTEST_CMP_LT) //!OCLINT bitwise operator in conditional - DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>=, " >= ", DOCTEST_CMP_GE) //!OCLINT bitwise operator in conditional - DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<=, " <= ", DOCTEST_CMP_LE) //!OCLINT bitwise operator in conditional - // clang-format on - - // forbidding some expressions based on this table: http://en.cppreference.com/w/cpp/language/operator_precedence - DOCTEST_FORBIT_EXPRESSION(&) - DOCTEST_FORBIT_EXPRESSION (^) - DOCTEST_FORBIT_EXPRESSION(|) - DOCTEST_FORBIT_EXPRESSION(&&) - DOCTEST_FORBIT_EXPRESSION(||) - DOCTEST_FORBIT_EXPRESSION(=) - DOCTEST_FORBIT_EXPRESSION(+=) - DOCTEST_FORBIT_EXPRESSION(-=) - DOCTEST_FORBIT_EXPRESSION(*=) - DOCTEST_FORBIT_EXPRESSION(/=) - DOCTEST_FORBIT_EXPRESSION(%=) - DOCTEST_FORBIT_EXPRESSION(<<=) - DOCTEST_FORBIT_EXPRESSION(>>=) - DOCTEST_FORBIT_EXPRESSION(&=) - DOCTEST_FORBIT_EXPRESSION(^=) - DOCTEST_FORBIT_EXPRESSION(|=) - // these 2 are unfortunate because they should be allowed - they have higher precedence over the comparisons, but the - // ExpressionDecomposer class uses the left shift operator to capture the left operand of the binary expression... - DOCTEST_FORBIT_EXPRESSION(<<) - DOCTEST_FORBIT_EXPRESSION(>>) - }; - -#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION - -#if defined(__clang__) -#pragma clang diagnostic pop -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic pop -#endif // > gcc 4.6 -#endif // __GNUC__ - -#ifdef _MSC_VER -#pragma warning(pop) -#endif // _MSC_VER - -#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION - - struct ExpressionDecomposer - { - assertType::Enum m_assert_type; - - ExpressionDecomposer(assertType::Enum assert_type) - : m_assert_type(assert_type) {} - - // The right operator for capturing expressions is "<=" instead of "<<" (based on the operator precedence table) - // but then there will be warnings from GCC about "-Wparentheses" and since "_Pragma()" is problematic this will stay for now... - // https://github.com/philsquared/Catch/issues/870 - // https://github.com/philsquared/Catch/issues/565 - template - Expression_lhs operator<<(const DOCTEST_REF_WRAP(L) operand) { - return Expression_lhs(operand, m_assert_type); - } - }; - - struct DOCTEST_INTERFACE TestCase - { - // not used for determining uniqueness - funcType m_test; // a function pointer to the test case - String m_full_name; // contains the name (only for templated test cases!) + the template type - const char* m_name; // name of the test case - const char* m_type; // for templated test cases - gets appended to the real name - const char* m_test_suite; // the test suite in which the test was added - const char* m_description; - bool m_skip; - bool m_may_fail; - bool m_should_fail; - int m_expected_failures; - double m_timeout; - - // fields by which uniqueness of test cases shall be determined - const char* m_file; // the file in which the test was registered - unsigned m_line; // the line where the test was registered - int m_template_id; // an ID used to distinguish between the different versions of a templated test case - - TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite, - const char* type = "", int template_id = -1); - - // for gcc 4.7 - DOCTEST_NOINLINE ~TestCase() {} - - TestCase& operator*(const char* in); - - template - TestCase& operator*(const T& in) { - in.fill(*this); - return *this; - } - - TestCase(const TestCase& other) { *this = other; } - - TestCase& operator=(const TestCase& other); - - bool operator<(const TestCase& other) const; - }; - - // forward declarations of functions used by the macros - DOCTEST_INTERFACE int regTest(const TestCase& tc); - DOCTEST_INTERFACE int setTestSuite(const TestSuite& ts); - - DOCTEST_INTERFACE void addFailedAssert(assertType::Enum assert_type); - - DOCTEST_INTERFACE void logTestStart(const TestCase& tc); - DOCTEST_INTERFACE void logTestEnd(); - - DOCTEST_INTERFACE void logTestException(const String& what, bool crash = false); - - DOCTEST_INTERFACE void logAssert(bool passed, const char* decomposition, bool threw, - const String& exception, const char* expr, - assertType::Enum assert_type, const char* file, int line); - - DOCTEST_INTERFACE void logAssertThrows(bool threw, const char* expr, - assertType::Enum assert_type, const char* file, - int line); - - DOCTEST_INTERFACE void logAssertThrowsAs(bool threw, bool threw_as, const char* as, - const String& exception, const char* expr, - assertType::Enum assert_type, const char* file, - int line); - - DOCTEST_INTERFACE void logAssertNothrow(bool threw, const String& exception, const char* expr, - assertType::Enum assert_type, const char* file, - int line); - - DOCTEST_INTERFACE bool isDebuggerActive(); - DOCTEST_INTERFACE void writeToDebugConsole(const String&); - - namespace binaryAssertComparison - { - enum Enum - { - eq = 0, - ne, - gt, - lt, - ge, - le - }; - } // namespace binaryAssertComparison - - // clang-format off - template struct RelationalComparator { bool operator()(const DOCTEST_REF_WRAP(L), const DOCTEST_REF_WRAP(R) ) const { return false; } }; - template struct RelationalComparator<0, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return eq(lhs, rhs); } }; - template struct RelationalComparator<1, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return ne(lhs, rhs); } }; - template struct RelationalComparator<2, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return gt(lhs, rhs); } }; - template struct RelationalComparator<3, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return lt(lhs, rhs); } }; - template struct RelationalComparator<4, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return ge(lhs, rhs); } }; - template struct RelationalComparator<5, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return le(lhs, rhs); } }; - // clang-format on - - struct DOCTEST_INTERFACE ResultBuilder - { - assertType::Enum m_assert_type; - const char* m_file; - int m_line; - const char* m_expr; - const char* m_exception_type; - - Result m_result; - bool m_threw; - bool m_threw_as; - bool m_failed; - String m_exception; - - ResultBuilder(assertType::Enum assert_type, const char* file, int line, const char* expr, - const char* exception_type = ""); - - ~ResultBuilder(); - - void setResult(const Result& res) { m_result = res; } - - template - DOCTEST_NOINLINE void binary_assert(const DOCTEST_REF_WRAP(L) lhs, - const DOCTEST_REF_WRAP(R) rhs) { - m_result.m_passed = RelationalComparator()(lhs, rhs); - if(!m_result.m_passed || getTestsContextState()->success) - m_result.m_decomposition = stringifyBinaryExpr(lhs, ", ", rhs); - } - - template - DOCTEST_NOINLINE void unary_assert(const DOCTEST_REF_WRAP(L) val) { - m_result.m_passed = !!val; - - if(m_assert_type & assertType::is_false) //!OCLINT bitwise operator in conditional - m_result.m_passed = !m_result.m_passed; - - if(!m_result.m_passed || getTestsContextState()->success) - m_result.m_decomposition = toString(val); - } - - void unexpectedExceptionOccurred(); - - bool log(); - void react() const; - }; - - namespace assertAction - { - enum Enum - { - nothing = 0, - dbgbreak = 1, - shouldthrow = 2 - }; - } // namespace assertAction - - template - DOCTEST_NOINLINE int fast_binary_assert(assertType::Enum assert_type, const char* file, - int line, const char* expr, - const DOCTEST_REF_WRAP(L) lhs, - const DOCTEST_REF_WRAP(R) rhs) { - ResultBuilder rb(assert_type, file, line, expr); - - rb.m_result.m_passed = RelationalComparator()(lhs, rhs); - - if(!rb.m_result.m_passed || getTestsContextState()->success) - rb.m_result.m_decomposition = stringifyBinaryExpr(lhs, ", ", rhs); - - int res = 0; - - if(rb.log()) - res |= assertAction::dbgbreak; - - if(rb.m_failed && checkIfShouldThrow(assert_type)) - res |= assertAction::shouldthrow; - -#ifdef DOCTEST_CONFIG_SUPER_FAST_ASSERTS - // ######################################################################################### - // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK TO SEE THE FAILING ASSERTION - // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED - // ######################################################################################### - if(res & assertAction::dbgbreak) - DOCTEST_BREAK_INTO_DEBUGGER(); - fastAssertThrowIfFlagSet(res); -#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS - - return res; - } - - template - DOCTEST_NOINLINE int fast_unary_assert(assertType::Enum assert_type, const char* file, int line, - const char* val_str, const DOCTEST_REF_WRAP(L) val) { - ResultBuilder rb(assert_type, file, line, val_str); - - rb.m_result.m_passed = !!val; - - if(assert_type & assertType::is_false) //!OCLINT bitwise operator in conditional - rb.m_result.m_passed = !rb.m_result.m_passed; - - if(!rb.m_result.m_passed || getTestsContextState()->success) - rb.m_result.m_decomposition = toString(val); - - int res = 0; - - if(rb.log()) - res |= assertAction::dbgbreak; - - if(rb.m_failed && checkIfShouldThrow(assert_type)) - res |= assertAction::shouldthrow; - -#ifdef DOCTEST_CONFIG_SUPER_FAST_ASSERTS - // ######################################################################################### - // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK TO SEE THE FAILING ASSERTION - // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED - // ######################################################################################### - if(res & assertAction::dbgbreak) - DOCTEST_BREAK_INTO_DEBUGGER(); - fastAssertThrowIfFlagSet(res); -#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS - - return res; - } - - struct DOCTEST_INTERFACE IExceptionTranslator //!OCLINT destructor of virtual class - { - virtual ~IExceptionTranslator(); - virtual bool translate(String&) const = 0; - }; - - template - class ExceptionTranslator : public IExceptionTranslator //!OCLINT destructor of virtual class - { - public: - explicit ExceptionTranslator(String (*translateFunction)(T)) - : m_translateFunction(translateFunction) {} - - bool translate(String& res) const { -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS - try { - throw; - // cppcheck-suppress catchExceptionByValue - } catch(T ex) { // NOLINT - res = m_translateFunction(ex); //!OCLINT parameter reassignment - return true; - } catch(...) {} //!OCLINT - empty catch statement -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - ((void)res); // to silence -Wunused-parameter - return false; - } - - protected: - String (*m_translateFunction)(T); - }; - - DOCTEST_INTERFACE void registerExceptionTranslatorImpl( - const IExceptionTranslator* translateFunction); - - // FIX FOR VISUAL STUDIO VERSIONS PRIOR TO 2015 - they failed to compile the call to operator<< with - // std::ostream passed as a reference noting that there is a use of an undefined type (which there isn't) - DOCTEST_INTERFACE void writeStringToStream(std::ostream* stream, const String& str); - - template - struct StringStreamBase - { - template - static void convert(std::ostream* stream, const T& in) { - writeStringToStream(stream, toString(in)); - } - - // always treat char* as a string in this context - no matter - // if DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING is defined - static void convert(std::ostream* stream, const char* in) { - writeStringToStream(stream, String(in)); - } - }; - - template <> - struct StringStreamBase - { - template - static void convert(std::ostream* stream, const T& in) { - *stream << in; - } - }; - - template - struct StringStream : StringStreamBase::value> - {}; - - template - void toStream(std::ostream* stream, const T& value) { - StringStream::convert(stream, value); - } - -#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING - DOCTEST_INTERFACE void toStream(std::ostream* stream, char* in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, const char* in); -#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING - DOCTEST_INTERFACE void toStream(std::ostream* stream, bool in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, float in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, double in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, double long in); - - DOCTEST_INTERFACE void toStream(std::ostream* stream, char in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, char signed in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, char unsigned in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int short in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int short unsigned in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int unsigned in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int long in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int long unsigned in); - -#ifdef DOCTEST_CONFIG_WITH_LONG_LONG - DOCTEST_INTERFACE void toStream(std::ostream* stream, int long long in); - DOCTEST_INTERFACE void toStream(std::ostream* stream, int long long unsigned in); -#endif // DOCTEST_CONFIG_WITH_LONG_LONG - - struct IContextScope //!OCLINT destructor of virtual class - { virtual void build(std::ostream*) = 0; }; - - DOCTEST_INTERFACE void addToContexts(IContextScope* ptr); - DOCTEST_INTERFACE void popFromContexts(); - DOCTEST_INTERFACE void useContextIfExceptionOccurred(IContextScope* ptr); - - // cppcheck-suppress copyCtorAndEqOperator - class ContextBuilder - { - friend class ContextScope; - - struct ICapture //!OCLINT destructor of virtual class - { virtual void toStream(std::ostream*) const = 0; }; - - template - struct Capture : ICapture //!OCLINT destructor of virtual class - { - const T* capture; - - explicit Capture(const T* in) - : capture(in) {} - virtual void toStream(std::ostream* stream) const { // override - doctest::detail::toStream(stream, *capture); - } - }; - - struct Chunk - { - char buf[sizeof(Capture)]; // place to construct a Capture - }; - - struct Node - { - Chunk chunk; - Node* next; - }; - - Chunk stackChunks[DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK]; - int numCaptures; - Node* head; - Node* tail; - - void build(std::ostream* stream) const { - int curr = 0; - // iterate over small buffer - while(curr < numCaptures && curr < DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK) - reinterpret_cast(stackChunks[curr++].buf)->toStream(stream); - // iterate over list - Node* curr_elem = head; - while(curr < numCaptures) { - reinterpret_cast(curr_elem->chunk.buf)->toStream(stream); - curr_elem = curr_elem->next; - ++curr; - } - } - - // steal the contents of the other - acting as a move constructor... - DOCTEST_NOINLINE ContextBuilder(ContextBuilder& other) - : numCaptures(other.numCaptures) - , head(other.head) - , tail(other.tail) { - other.numCaptures = 0; - other.head = 0; - other.tail = 0; - my_memcpy(stackChunks, other.stackChunks, - unsigned(int(sizeof(Chunk)) * DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK)); - } - - public: - // cppcheck-suppress uninitMemberVar - DOCTEST_NOINLINE ContextBuilder() // NOLINT - : numCaptures(0) - , head(0) - , tail(0) {} - - template - DOCTEST_NOINLINE ContextBuilder& operator<<(T& in) { - Capture temp(&in); - - // construct either on stack or on heap - // copy the bytes for the whole object - including the vtable because we cant construct - // the object directly in the buffer using placement new - need the header... - if(numCaptures < DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK) { - my_memcpy(stackChunks[numCaptures].buf, &temp, sizeof(Chunk)); - } else { - Node* curr = new Node; - curr->next = 0; - if(tail) { - tail->next = curr; - tail = curr; - } else { - head = tail = curr; - } - - my_memcpy(tail->chunk.buf, &temp, sizeof(Chunk)); - } - ++numCaptures; - return *this; - } - - DOCTEST_NOINLINE ~ContextBuilder() { - // free the linked list - the ones on the stack are left as-is - // no destructors are called at all - there is no need - while(head) { - Node* next = head->next; - delete head; - head = next; - } - } - -#ifdef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES - template - ContextBuilder& operator<<(const T&&) { - DOCTEST_STATIC_ASSERT( - deferred_false::value, - Cannot_pass_temporaries_or_rvalues_to_the_streaming_operator_because_it_caches_pointers_to_the_passed_objects_for_lazy_evaluation); - return *this; - } -#endif // DOCTEST_CONFIG_WITH_RVALUE_REFERENCES - }; - - class ContextScope : public IContextScope //!OCLINT destructor of virtual class - { - ContextBuilder contextBuilder; - bool built; - - public: - DOCTEST_NOINLINE explicit ContextScope(ContextBuilder& temp) - : contextBuilder(temp) - , built(false) { - addToContexts(this); - } - - DOCTEST_NOINLINE ~ContextScope() { - if(!built) - useContextIfExceptionOccurred(this); - popFromContexts(); - } - - void build(std::ostream* stream) { - built = true; - contextBuilder.build(stream); - } - }; - - class DOCTEST_INTERFACE MessageBuilder - { - std::ostream* m_stream; - const char* m_file; - int m_line; - doctest::detail::assertType::Enum m_severity; - - public: - MessageBuilder(const char* file, int line, doctest::detail::assertType::Enum severity); - ~MessageBuilder(); - - template - MessageBuilder& operator<<(const T& in) { - doctest::detail::toStream(m_stream, in); - return *this; - } - - bool log(); - void react(); - }; -} // namespace detail - -struct test_suite -{ - const char* data; - test_suite(const char* in) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_test_suite = data; } - void fill(detail::TestSuite& state) const { state.m_test_suite = data; } -}; - -struct description -{ - const char* data; - description(const char* in) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_description = data; } - void fill(detail::TestSuite& state) const { state.m_description = data; } -}; - -struct skip -{ - bool data; - skip(bool in = true) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_skip = data; } - void fill(detail::TestSuite& state) const { state.m_skip = data; } -}; - -struct timeout -{ - double data; - timeout(double in) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_timeout = data; } - void fill(detail::TestSuite& state) const { state.m_timeout = data; } -}; - -struct may_fail -{ - bool data; - may_fail(bool in = true) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_may_fail = data; } - void fill(detail::TestSuite& state) const { state.m_may_fail = data; } -}; - -struct should_fail -{ - bool data; - should_fail(bool in = true) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_should_fail = data; } - void fill(detail::TestSuite& state) const { state.m_should_fail = data; } -}; - -struct expected_failures -{ - int data; - expected_failures(int in) - : data(in) {} - void fill(detail::TestCase& state) const { state.m_expected_failures = data; } - void fill(detail::TestSuite& state) const { state.m_expected_failures = data; } -}; - -#endif // DOCTEST_CONFIG_DISABLE - -#ifndef DOCTEST_CONFIG_DISABLE -template -int registerExceptionTranslator(String (*translateFunction)(T)) { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wexit-time-destructors" -#endif // __clang__ - static detail::ExceptionTranslator exceptionTranslator(translateFunction); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif // __clang__ - detail::registerExceptionTranslatorImpl(&exceptionTranslator); - return 0; -} - -#else // DOCTEST_CONFIG_DISABLE -template -int registerExceptionTranslator(String (*)(T)) { - return 0; -} -#endif // DOCTEST_CONFIG_DISABLE - -DOCTEST_INTERFACE bool isRunningInTest(); - -// cppcheck-suppress noCopyConstructor -class DOCTEST_INTERFACE Context -{ -#if !defined(DOCTEST_CONFIG_DISABLE) - detail::ContextState* p; - - void parseArgs(int argc, const char* const* argv, bool withDefaults = false); - -#endif // DOCTEST_CONFIG_DISABLE - -public: - explicit Context(int argc = 0, const char* const* argv = 0); - - ~Context(); - - void applyCommandLine(int argc, const char* const* argv); - - void addFilter(const char* filter, const char* value); - void clearFilters(); - void setOption(const char* option, int value); - void setOption(const char* option, const char* value); - - bool shouldExit(); - - int run(); -}; - -} // namespace doctest - -// if registering is not disabled -#if !defined(DOCTEST_CONFIG_DISABLE) - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_EXPAND_VA_ARGS(...) __VA_ARGS__ -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_EXPAND_VA_ARGS -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_STRIP_PARENS(x) x -#define DOCTEST_HANDLE_BRACED_VA_ARGS(expr) DOCTEST_STRIP_PARENS(DOCTEST_EXPAND_VA_ARGS expr) - -// registers the test by initializing a dummy var with a function -#define DOCTEST_REGISTER_FUNCTION(f, decorators) \ - DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) = doctest::detail::regTest( \ - doctest::detail::TestCase(f, __FILE__, __LINE__, \ - doctest_detail_test_suite_ns::getCurrentTestSuite()) * \ - decorators); \ - DOCTEST_GLOBAL_NO_WARNINGS_END() - -#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, decorators) \ - namespace \ - { \ - struct der : base \ - { void f(); }; \ - static void func() { \ - der v; \ - v.f(); \ - } \ - DOCTEST_REGISTER_FUNCTION(func, decorators) \ - } \ - inline DOCTEST_NOINLINE void der::f() - -#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, decorators) \ - static void f(); \ - DOCTEST_REGISTER_FUNCTION(f, decorators) \ - static void f() - -// for registering tests -#define DOCTEST_TEST_CASE(decorators) \ - DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), decorators) - -// for registering tests with a fixture -#define DOCTEST_TEST_CASE_FIXTURE(c, decorators) \ - DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(_DOCTEST_ANON_CLASS_), c, \ - DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), decorators) - -// for converting types to strings without the header and demangling -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TYPE_TO_STRING_IMPL(...) \ - template <> \ - inline const char* type_to_string<__VA_ARGS__>() { \ - return "<" #__VA_ARGS__ ">"; \ - } -#define DOCTEST_TYPE_TO_STRING(...) \ - namespace doctest \ - { \ - namespace detail \ - { DOCTEST_TYPE_TO_STRING_IMPL(__VA_ARGS__) } \ - } \ - typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TYPE_TO_STRING_IMPL(x) \ - template <> \ - inline const char* type_to_string() { \ - return "<" #x ">"; \ - } -#define DOCTEST_TYPE_TO_STRING(x) \ - namespace doctest \ - { \ - namespace detail \ - { DOCTEST_TYPE_TO_STRING_IMPL(x) } \ - } \ - typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -// for typed tests -#define DOCTEST_TEST_CASE_TEMPLATE_IMPL(decorators, T, types, anon) \ - template \ - inline void anon(); \ - struct DOCTEST_CAT(anon, FUNCTOR) \ - { \ - template \ - void operator()() { \ - doctest::detail::regTest( \ - doctest::detail::TestCase(anon, __FILE__, __LINE__, \ - doctest_detail_test_suite_ns::getCurrentTestSuite(), \ - doctest::detail::type_to_string(), Index) * \ - decorators); \ - } \ - }; \ - inline int DOCTEST_CAT(anon, REG_FUNC)() { \ - DOCTEST_CAT(anon, FUNCTOR) registrar; \ - doctest::detail::ForEachType \ - doIt(registrar); \ - return 0; \ - } \ - DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY)) = DOCTEST_CAT(anon, REG_FUNC)(); \ - DOCTEST_GLOBAL_NO_WARNINGS_END() \ - template \ - inline void anon() - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TEST_CASE_TEMPLATE(decorators, T, ...) \ - DOCTEST_TEST_CASE_TEMPLATE_IMPL(decorators, T, (__VA_ARGS__), \ - DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TEST_CASE_TEMPLATE(decorators, T, types) \ - DOCTEST_TEST_CASE_TEMPLATE_IMPL(decorators, T, types, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(decorators, T, id, anon) \ - template \ - inline void anon(); \ - struct DOCTEST_CAT(id, _FUNCTOR) \ - { \ - int m_line; \ - DOCTEST_CAT(id, _FUNCTOR) \ - (int line) \ - : m_line(line) {} \ - template \ - void operator()() { \ - doctest::detail::regTest( \ - doctest::detail::TestCase(anon, __FILE__, __LINE__, \ - doctest_detail_test_suite_ns::getCurrentTestSuite(), \ - doctest::detail::type_to_string(), \ - m_line * 1000 + Index) * \ - decorators); \ - } \ - }; \ - template \ - inline void anon() - -#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(decorators, T, id) \ - DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(decorators, T, id, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)) - -#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, types, anon) \ - static int DOCTEST_CAT(anon, REG_FUNC)() { \ - DOCTEST_CAT(id, _FUNCTOR) registrar(__LINE__); \ - doctest::detail::ForEachType \ - doIt(registrar); \ - return 0; \ - } \ - DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY)) = DOCTEST_CAT(anon, REG_FUNC)(); \ - DOCTEST_GLOBAL_NO_WARNINGS_END() typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) \ - DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, (__VA_ARGS__), \ - DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, types) \ - DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, types, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -// for subcases -#if defined(__GNUC__) -#define DOCTEST_SUBCASE(name) \ - if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUBCASE_) \ - __attribute__((unused)) = \ - doctest::detail::Subcase(name, __FILE__, __LINE__)) -#else // __GNUC__ -#define DOCTEST_SUBCASE(name) \ - if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUBCASE_) = \ - doctest::detail::Subcase(name, __FILE__, __LINE__)) -#endif // __GNUC__ - -// for grouping tests in test suites by using code blocks -#define DOCTEST_TEST_SUITE_IMPL(decorators, ns_name) \ - namespace ns_name \ - { \ - namespace doctest_detail_test_suite_ns \ - { \ - inline DOCTEST_NOINLINE doctest::detail::TestSuite& getCurrentTestSuite() { \ - static doctest::detail::TestSuite data; \ - static bool inited = false; \ - if(!inited) { \ - data* decorators; \ - inited = true; \ - } \ - return data; \ - } \ - } \ - } \ - namespace ns_name - -#define DOCTEST_TEST_SUITE(decorators) \ - DOCTEST_TEST_SUITE_IMPL(decorators, DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUITE_)) - -// for starting a testsuite block -#define DOCTEST_TEST_SUITE_BEGIN(decorators) \ - DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) = \ - doctest::detail::setTestSuite(doctest::detail::TestSuite() * decorators); \ - DOCTEST_GLOBAL_NO_WARNINGS_END() \ - typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) - -// for ending a testsuite block -#define DOCTEST_TEST_SUITE_END \ - DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) = \ - doctest::detail::setTestSuite(doctest::detail::TestSuite() * ""); \ - DOCTEST_GLOBAL_NO_WARNINGS_END() \ - typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) - -// for registering exception translators -#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(translatorName, signature) \ - static doctest::String translatorName(signature); \ - DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_)) = \ - doctest::registerExceptionTranslator(translatorName); \ - DOCTEST_GLOBAL_NO_WARNINGS_END() \ - static doctest::String translatorName(signature) - -#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) \ - DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_), \ - signature) - -// for logging -#define DOCTEST_INFO(x) \ - doctest::detail::ContextScope DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_)( \ - doctest::detail::ContextBuilder() << x) -#define DOCTEST_CAPTURE(x) DOCTEST_INFO(#x " := " << x) - -#define DOCTEST_ADD_AT_IMPL(type, file, line, mb, x) \ - do { \ - doctest::detail::MessageBuilder mb(file, line, doctest::detail::assertType::type); \ - mb << x; \ - if(mb.log()) \ - DOCTEST_BREAK_INTO_DEBUGGER(); \ - mb.react(); \ - } while((void)0, 0) - -// clang-format off -#define DOCTEST_ADD_MESSAGE_AT(file, line, x) DOCTEST_ADD_AT_IMPL(is_warn, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), x) -#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, x) DOCTEST_ADD_AT_IMPL(is_check, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), x) -#define DOCTEST_ADD_FAIL_AT(file, line, x) DOCTEST_ADD_AT_IMPL(is_require, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), x) -// clang-format on - -#define DOCTEST_MESSAGE(x) DOCTEST_ADD_MESSAGE_AT(__FILE__, __LINE__, x) -#define DOCTEST_FAIL_CHECK(x) DOCTEST_ADD_FAIL_CHECK_AT(__FILE__, __LINE__, x) -#define DOCTEST_FAIL(x) DOCTEST_ADD_FAIL_AT(__FILE__, __LINE__, x) - -#if __cplusplus >= 201402L || (defined(_MSC_VER) && _MSC_VER >= 1910) -template -constexpr T to_lvalue = x; -#define DOCTEST_TO_LVALUE(...) to_lvalue -#else -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TO_LVALUE(...) TO_LVALUE_CAN_BE_USED_ONLY_IN_CPP14_MODE_OR_WITH_VS_2017_OR_NEWER -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TO_LVALUE(x) TO_LVALUE_CAN_BE_USED_ONLY_IN_CPP14_MODE_OR_WITH_VS_2017_OR_NEWER -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#endif // TO_LVALUE hack for logging macros like INFO() - -// common code in asserts - for convenience -#define DOCTEST_ASSERT_LOG_AND_REACT(rb) \ - if(rb.log()) \ - DOCTEST_BREAK_INTO_DEBUGGER(); \ - rb.react() - -#ifdef DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS -#define DOCTEST_WRAP_IN_TRY(x) x; -#else // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS -#define DOCTEST_WRAP_IN_TRY(x) \ - try { \ - x; \ - } catch(...) { _DOCTEST_RB.unexpectedExceptionOccurred(); } -#endif // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS - -#define DOCTEST_ASSERT_IMPLEMENT_3(expr, assert_type) \ - doctest::detail::ResultBuilder _DOCTEST_RB( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr))); \ - DOCTEST_WRAP_IN_TRY(_DOCTEST_RB.setResult( \ - doctest::detail::ExpressionDecomposer(doctest::detail::assertType::assert_type) \ - << DOCTEST_HANDLE_BRACED_VA_ARGS(expr))) \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB) - -#if defined(__clang__) -#define DOCTEST_ASSERT_IMPLEMENT_2(expr, assert_type) \ - _Pragma("clang diagnostic push") \ - _Pragma("clang diagnostic ignored \"-Woverloaded-shift-op-parentheses\"") \ - DOCTEST_ASSERT_IMPLEMENT_3(expr, assert_type); \ - _Pragma("clang diagnostic pop") -#else // __clang__ -#define DOCTEST_ASSERT_IMPLEMENT_2(expr, assert_type) DOCTEST_ASSERT_IMPLEMENT_3(expr, assert_type); -#endif // __clang__ - -#define DOCTEST_ASSERT_IMPLEMENT_1(expr, assert_type) \ - do { \ - DOCTEST_ASSERT_IMPLEMENT_2(expr, assert_type); \ - } while((void)0, 0) - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN(...) DOCTEST_ASSERT_IMPLEMENT_1((__VA_ARGS__), DT_WARN) -#define DOCTEST_CHECK(...) DOCTEST_ASSERT_IMPLEMENT_1((__VA_ARGS__), DT_CHECK) -#define DOCTEST_REQUIRE(...) DOCTEST_ASSERT_IMPLEMENT_1((__VA_ARGS__), DT_REQUIRE) -#define DOCTEST_WARN_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1((__VA_ARGS__), DT_WARN_FALSE) -#define DOCTEST_CHECK_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1((__VA_ARGS__), DT_CHECK_FALSE) -#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1((__VA_ARGS__), DT_REQUIRE_FALSE) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN(expr) DOCTEST_ASSERT_IMPLEMENT_1(expr, DT_WARN) -#define DOCTEST_CHECK(expr) DOCTEST_ASSERT_IMPLEMENT_1(expr, DT_CHECK) -#define DOCTEST_REQUIRE(expr) DOCTEST_ASSERT_IMPLEMENT_1(expr, DT_REQUIRE) -#define DOCTEST_WARN_FALSE(expr) DOCTEST_ASSERT_IMPLEMENT_1(expr, DT_WARN_FALSE) -#define DOCTEST_CHECK_FALSE(expr) DOCTEST_ASSERT_IMPLEMENT_1(expr, DT_CHECK_FALSE) -#define DOCTEST_REQUIRE_FALSE(expr) DOCTEST_ASSERT_IMPLEMENT_1(expr, DT_REQUIRE_FALSE) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -// clang-format off -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2((cond), DT_WARN); } while((void)0, 0) -#define DOCTEST_CHECK_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2((cond), DT_CHECK); } while((void)0, 0) -#define DOCTEST_REQUIRE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2((cond), DT_REQUIRE); } while((void)0, 0) -#define DOCTEST_WARN_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2((cond), DT_WARN_FALSE); } while((void)0, 0) -#define DOCTEST_CHECK_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2((cond), DT_CHECK_FALSE); } while((void)0, 0) -#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2((cond), DT_REQUIRE_FALSE); } while((void)0, 0) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(cond, DT_WARN); } while((void)0, 0) -#define DOCTEST_CHECK_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(cond, DT_CHECK); } while((void)0, 0) -#define DOCTEST_REQUIRE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(cond, DT_REQUIRE); } while((void)0, 0) -#define DOCTEST_WARN_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(cond, DT_WARN_FALSE); } while((void)0, 0) -#define DOCTEST_CHECK_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(cond, DT_CHECK_FALSE); } while((void)0, 0) -#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(cond, DT_REQUIRE_FALSE); } while((void)0, 0) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -// clang-format on - -#define DOCTEST_ASSERT_THROWS(expr, assert_type) \ - do { \ - if(!doctest::detail::getTestsContextState()->no_throw) { \ - doctest::detail::ResultBuilder _DOCTEST_RB(doctest::detail::assertType::assert_type, \ - __FILE__, __LINE__, #expr); \ - try { \ - expr; \ - } catch(...) { _DOCTEST_RB.m_threw = true; } \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ - } \ - } while((void)0, 0) - -#define DOCTEST_ASSERT_THROWS_AS(expr, as, assert_type) \ - do { \ - if(!doctest::detail::getTestsContextState()->no_throw) { \ - doctest::detail::ResultBuilder _DOCTEST_RB( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, #expr, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(as))); \ - try { \ - expr; \ - } catch(DOCTEST_HANDLE_BRACED_VA_ARGS(as)) { \ - _DOCTEST_RB.m_threw = true; \ - _DOCTEST_RB.m_threw_as = true; \ - } catch(...) { _DOCTEST_RB.unexpectedExceptionOccurred(); } \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ - } \ - } while((void)0, 0) - -#define DOCTEST_ASSERT_NOTHROW(expr, assert_type) \ - do { \ - if(!doctest::detail::getTestsContextState()->no_throw) { \ - doctest::detail::ResultBuilder _DOCTEST_RB(doctest::detail::assertType::assert_type, \ - __FILE__, __LINE__, #expr); \ - try { \ - expr; \ - } catch(...) { _DOCTEST_RB.unexpectedExceptionOccurred(); } \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ - } \ - } while((void)0, 0) - -#define DOCTEST_WARN_THROWS(expr) DOCTEST_ASSERT_THROWS(expr, DT_WARN_THROWS) -#define DOCTEST_CHECK_THROWS(expr) DOCTEST_ASSERT_THROWS(expr, DT_CHECK_THROWS) -#define DOCTEST_REQUIRE_THROWS(expr) DOCTEST_ASSERT_THROWS(expr, DT_REQUIRE_THROWS) - -// clang-format off -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, (__VA_ARGS__), DT_WARN_THROWS_AS) -#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, (__VA_ARGS__), DT_CHECK_THROWS_AS) -#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, (__VA_ARGS__), DT_REQUIRE_THROWS_AS) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_THROWS_AS(expr, ex) DOCTEST_ASSERT_THROWS_AS(expr, ex, DT_WARN_THROWS_AS) -#define DOCTEST_CHECK_THROWS_AS(expr, ex) DOCTEST_ASSERT_THROWS_AS(expr, ex, DT_CHECK_THROWS_AS) -#define DOCTEST_REQUIRE_THROWS_AS(expr, ex) DOCTEST_ASSERT_THROWS_AS(expr, ex, DT_REQUIRE_THROWS_AS) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -// clang-format on - -#define DOCTEST_WARN_NOTHROW(expr) DOCTEST_ASSERT_NOTHROW(expr, DT_WARN_NOTHROW) -#define DOCTEST_CHECK_NOTHROW(expr) DOCTEST_ASSERT_NOTHROW(expr, DT_CHECK_NOTHROW) -#define DOCTEST_REQUIRE_NOTHROW(expr) DOCTEST_ASSERT_NOTHROW(expr, DT_REQUIRE_NOTHROW) - -// clang-format off -#define DOCTEST_WARN_THROWS_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_THROWS(expr); } while((void)0, 0) -#define DOCTEST_CHECK_THROWS_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_THROWS(expr); } while((void)0, 0) -#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_THROWS(expr); } while((void)0, 0) -#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_THROWS_AS(expr, ex); } while((void)0, 0) -#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_THROWS_AS(expr, ex); } while((void)0, 0) -#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_THROWS_AS(expr, ex); } while((void)0, 0) -#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_NOTHROW(expr); } while((void)0, 0) -#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_NOTHROW(expr); } while((void)0, 0) -#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_NOTHROW(expr); } while((void)0, 0) -// clang-format on - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_BINARY_ASSERT(assert_type, expr, comp) \ - do { \ - doctest::detail::ResultBuilder _DOCTEST_RB( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr))); \ - DOCTEST_WRAP_IN_TRY( \ - _DOCTEST_RB.binary_assert( \ - DOCTEST_HANDLE_BRACED_VA_ARGS(expr))) \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ - } while((void)0, 0) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_BINARY_ASSERT(assert_type, lhs, rhs, comp) \ - do { \ - doctest::detail::ResultBuilder _DOCTEST_RB(doctest::detail::assertType::assert_type, \ - __FILE__, __LINE__, #lhs ", " #rhs); \ - DOCTEST_WRAP_IN_TRY( \ - _DOCTEST_RB.binary_assert(lhs, \ - rhs)) \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ - } while((void)0, 0) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_UNARY_ASSERT(assert_type, expr) \ - do { \ - doctest::detail::ResultBuilder _DOCTEST_RB( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr))); \ - DOCTEST_WRAP_IN_TRY(_DOCTEST_RB.unary_assert(DOCTEST_HANDLE_BRACED_VA_ARGS(expr))) \ - DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ - } while((void)0, 0) - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_EQ(...) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, (__VA_ARGS__), eq) -#define DOCTEST_CHECK_EQ(...) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, (__VA_ARGS__), eq) -#define DOCTEST_REQUIRE_EQ(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, (__VA_ARGS__), eq) -#define DOCTEST_WARN_NE(...) DOCTEST_BINARY_ASSERT(DT_WARN_NE, (__VA_ARGS__), ne) -#define DOCTEST_CHECK_NE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, (__VA_ARGS__), ne) -#define DOCTEST_REQUIRE_NE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, (__VA_ARGS__), ne) -#define DOCTEST_WARN_GT(...) DOCTEST_BINARY_ASSERT(DT_WARN_GT, (__VA_ARGS__), gt) -#define DOCTEST_CHECK_GT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, (__VA_ARGS__), gt) -#define DOCTEST_REQUIRE_GT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, (__VA_ARGS__), gt) -#define DOCTEST_WARN_LT(...) DOCTEST_BINARY_ASSERT(DT_WARN_LT, (__VA_ARGS__), lt) -#define DOCTEST_CHECK_LT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, (__VA_ARGS__), lt) -#define DOCTEST_REQUIRE_LT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, (__VA_ARGS__), lt) -#define DOCTEST_WARN_GE(...) DOCTEST_BINARY_ASSERT(DT_WARN_GE, (__VA_ARGS__), ge) -#define DOCTEST_CHECK_GE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, (__VA_ARGS__), ge) -#define DOCTEST_REQUIRE_GE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, (__VA_ARGS__), ge) -#define DOCTEST_WARN_LE(...) DOCTEST_BINARY_ASSERT(DT_WARN_LE, (__VA_ARGS__), le) -#define DOCTEST_CHECK_LE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, (__VA_ARGS__), le) -#define DOCTEST_REQUIRE_LE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, (__VA_ARGS__), le) - -#define DOCTEST_WARN_UNARY(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, (__VA_ARGS__)) -#define DOCTEST_CHECK_UNARY(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, (__VA_ARGS__)) -#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, (__VA_ARGS__)) -#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, (__VA_ARGS__)) -#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, (__VA_ARGS__)) -#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, (__VA_ARGS__)) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_EQ(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, lhs, rhs, eq) -#define DOCTEST_CHECK_EQ(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, lhs, rhs, eq) -#define DOCTEST_REQUIRE_EQ(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, lhs, rhs, eq) -#define DOCTEST_WARN_NE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_WARN_NE, lhs, rhs, ne) -#define DOCTEST_CHECK_NE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, lhs, rhs, ne) -#define DOCTEST_REQUIRE_NE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, lhs, rhs, ne) -#define DOCTEST_WARN_GT(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_WARN_GT, lhs, rhs, gt) -#define DOCTEST_CHECK_GT(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, lhs, rhs, gt) -#define DOCTEST_REQUIRE_GT(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, lhs, rhs, gt) -#define DOCTEST_WARN_LT(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_WARN_LT, lhs, rhs, lt) -#define DOCTEST_CHECK_LT(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, lhs, rhs, lt) -#define DOCTEST_REQUIRE_LT(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, lhs, rhs, lt) -#define DOCTEST_WARN_GE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_WARN_GE, lhs, rhs, ge) -#define DOCTEST_CHECK_GE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, lhs, rhs, ge) -#define DOCTEST_REQUIRE_GE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, lhs, rhs, ge) -#define DOCTEST_WARN_LE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_WARN_LE, lhs, rhs, le) -#define DOCTEST_CHECK_LE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, lhs, rhs, le) -#define DOCTEST_REQUIRE_LE(lhs, rhs) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, lhs, rhs, le) - -#define DOCTEST_WARN_UNARY(v) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, v) -#define DOCTEST_CHECK_UNARY(v) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, v) -#define DOCTEST_REQUIRE_UNARY(v) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, v) -#define DOCTEST_WARN_UNARY_FALSE(v) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, v) -#define DOCTEST_CHECK_UNARY_FALSE(v) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, v) -#define DOCTEST_REQUIRE_UNARY_FALSE(v) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, v) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_FAST_BINARY_ASSERT(assert_type, expr, comparison) \ - do { \ - int _DOCTEST_FAST_RES = doctest::detail::fast_binary_assert< \ - doctest::detail::binaryAssertComparison::comparison>( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr)), \ - DOCTEST_HANDLE_BRACED_VA_ARGS(expr)); \ - if(_DOCTEST_FAST_RES & doctest::detail::assertAction::dbgbreak) \ - DOCTEST_BREAK_INTO_DEBUGGER(); \ - doctest::detail::fastAssertThrowIfFlagSet(_DOCTEST_FAST_RES); \ - } while((void)0, 0) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_FAST_BINARY_ASSERT(assert_type, lhs, rhs, comparison) \ - do { \ - int _DOCTEST_FAST_RES = doctest::detail::fast_binary_assert< \ - doctest::detail::binaryAssertComparison::comparison>( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, #lhs ", " #rhs, lhs, \ - rhs); \ - if(_DOCTEST_FAST_RES & doctest::detail::assertAction::dbgbreak) \ - DOCTEST_BREAK_INTO_DEBUGGER(); \ - doctest::detail::fastAssertThrowIfFlagSet(_DOCTEST_FAST_RES); \ - } while((void)0, 0) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_FAST_UNARY_ASSERT(assert_type, expr) \ - do { \ - int _DOCTEST_FAST_RES = doctest::detail::fast_unary_assert( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr)), \ - DOCTEST_HANDLE_BRACED_VA_ARGS(expr)); \ - if(_DOCTEST_FAST_RES & doctest::detail::assertAction::dbgbreak) \ - DOCTEST_BREAK_INTO_DEBUGGER(); \ - doctest::detail::fastAssertThrowIfFlagSet(_DOCTEST_FAST_RES); \ - } while((void)0, 0) - -#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_FAST_BINARY_ASSERT(assert_type, expr, comparison) \ - doctest::detail::fast_binary_assert( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr)), \ - DOCTEST_HANDLE_BRACED_VA_ARGS(expr)) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_FAST_BINARY_ASSERT(assert_type, lhs, rhs, comparison) \ - doctest::detail::fast_binary_assert( \ - doctest::detail::assertType::assert_type, __FILE__, __LINE__, #lhs ", " #rhs, lhs, \ - rhs) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_FAST_UNARY_ASSERT(assert_type, expr) \ - doctest::detail::fast_unary_assert(doctest::detail::assertType::assert_type, __FILE__, \ - __LINE__, \ - DOCTEST_TOSTR(DOCTEST_HANDLE_BRACED_VA_ARGS(expr)), \ - DOCTEST_HANDLE_BRACED_VA_ARGS(expr)) - -#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS - -// clang-format off -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_FAST_WARN_EQ(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_EQ, (__VA_ARGS__), eq) -#define DOCTEST_FAST_CHECK_EQ(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_EQ, (__VA_ARGS__), eq) -#define DOCTEST_FAST_REQUIRE_EQ(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_EQ, (__VA_ARGS__), eq) -#define DOCTEST_FAST_WARN_NE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_NE, (__VA_ARGS__), ne) -#define DOCTEST_FAST_CHECK_NE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_NE, (__VA_ARGS__), ne) -#define DOCTEST_FAST_REQUIRE_NE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_NE, (__VA_ARGS__), ne) -#define DOCTEST_FAST_WARN_GT(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_GT, (__VA_ARGS__), gt) -#define DOCTEST_FAST_CHECK_GT(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_GT, (__VA_ARGS__), gt) -#define DOCTEST_FAST_REQUIRE_GT(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_GT, (__VA_ARGS__), gt) -#define DOCTEST_FAST_WARN_LT(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_LT, (__VA_ARGS__), lt) -#define DOCTEST_FAST_CHECK_LT(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_LT, (__VA_ARGS__), lt) -#define DOCTEST_FAST_REQUIRE_LT(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_LT, (__VA_ARGS__), lt) -#define DOCTEST_FAST_WARN_GE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_GE, (__VA_ARGS__), ge) -#define DOCTEST_FAST_CHECK_GE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_GE, (__VA_ARGS__), ge) -#define DOCTEST_FAST_REQUIRE_GE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_GE, (__VA_ARGS__), ge) -#define DOCTEST_FAST_WARN_LE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_LE, (__VA_ARGS__), le) -#define DOCTEST_FAST_CHECK_LE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_LE, (__VA_ARGS__), le) -#define DOCTEST_FAST_REQUIRE_LE(...) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_LE, (__VA_ARGS__), le) - -#define DOCTEST_FAST_WARN_UNARY(...) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_WARN_UNARY, (__VA_ARGS__)) -#define DOCTEST_FAST_CHECK_UNARY(...) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_CHECK_UNARY, (__VA_ARGS__)) -#define DOCTEST_FAST_REQUIRE_UNARY(...) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_REQUIRE_UNARY, (__VA_ARGS__)) -#define DOCTEST_FAST_WARN_UNARY_FALSE(...) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_WARN_UNARY_FALSE, (__VA_ARGS__)) -#define DOCTEST_FAST_CHECK_UNARY_FALSE(...) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_CHECK_UNARY_FALSE, (__VA_ARGS__)) -#define DOCTEST_FAST_REQUIRE_UNARY_FALSE(...) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_REQUIRE_UNARY_FALSE, (__VA_ARGS__)) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_FAST_WARN_EQ(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_EQ, l, r, eq) -#define DOCTEST_FAST_CHECK_EQ(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_EQ, l, r, eq) -#define DOCTEST_FAST_REQUIRE_EQ(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_EQ, l, r, eq) -#define DOCTEST_FAST_WARN_NE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_NE, l, r, ne) -#define DOCTEST_FAST_CHECK_NE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_NE, l, r, ne) -#define DOCTEST_FAST_REQUIRE_NE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_NE, l, r, ne) -#define DOCTEST_FAST_WARN_GT(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_GT, l, r, gt) -#define DOCTEST_FAST_CHECK_GT(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_GT, l, r, gt) -#define DOCTEST_FAST_REQUIRE_GT(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_GT, l, r, gt) -#define DOCTEST_FAST_WARN_LT(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_LT, l, r, lt) -#define DOCTEST_FAST_CHECK_LT(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_LT, l, r, lt) -#define DOCTEST_FAST_REQUIRE_LT(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_LT, l, r, lt) -#define DOCTEST_FAST_WARN_GE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_GE, l, r, ge) -#define DOCTEST_FAST_CHECK_GE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_GE, l, r, ge) -#define DOCTEST_FAST_REQUIRE_GE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_GE, l, r, ge) -#define DOCTEST_FAST_WARN_LE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_WARN_LE, l, r, le) -#define DOCTEST_FAST_CHECK_LE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_CHECK_LE, l, r, le) -#define DOCTEST_FAST_REQUIRE_LE(l, r) DOCTEST_FAST_BINARY_ASSERT(DT_FAST_REQUIRE_LE, l, r, le) - -#define DOCTEST_FAST_WARN_UNARY(v) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_WARN_UNARY, v) -#define DOCTEST_FAST_CHECK_UNARY(v) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_CHECK_UNARY, v) -#define DOCTEST_FAST_REQUIRE_UNARY(v) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_REQUIRE_UNARY, v) -#define DOCTEST_FAST_WARN_UNARY_FALSE(v) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_WARN_UNARY_FALSE, v) -#define DOCTEST_FAST_CHECK_UNARY_FALSE(v) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_CHECK_UNARY_FALSE, v) -#define DOCTEST_FAST_REQUIRE_UNARY_FALSE(v) DOCTEST_FAST_UNARY_ASSERT(DT_FAST_REQUIRE_UNARY_FALSE, v) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -// clang-format on - -#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS - -#undef DOCTEST_WARN_THROWS -#undef DOCTEST_CHECK_THROWS -#undef DOCTEST_REQUIRE_THROWS -#undef DOCTEST_WARN_THROWS_AS -#undef DOCTEST_CHECK_THROWS_AS -#undef DOCTEST_REQUIRE_THROWS_AS -#undef DOCTEST_WARN_NOTHROW -#undef DOCTEST_CHECK_NOTHROW -#undef DOCTEST_REQUIRE_NOTHROW - -#undef DOCTEST_WARN_THROWS_MESSAGE -#undef DOCTEST_CHECK_THROWS_MESSAGE -#undef DOCTEST_REQUIRE_THROWS_MESSAGE -#undef DOCTEST_WARN_THROWS_AS_MESSAGE -#undef DOCTEST_CHECK_THROWS_AS_MESSAGE -#undef DOCTEST_REQUIRE_THROWS_AS_MESSAGE -#undef DOCTEST_WARN_NOTHROW_MESSAGE -#undef DOCTEST_CHECK_NOTHROW_MESSAGE -#undef DOCTEST_REQUIRE_NOTHROW_MESSAGE - -#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS - -#define DOCTEST_WARN_THROWS(expr) ((void)0) -#define DOCTEST_CHECK_THROWS(expr) ((void)0) -#define DOCTEST_REQUIRE_THROWS(expr) ((void)0) -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_THROWS_AS(expr, ...) ((void)0) -#define DOCTEST_CHECK_THROWS_AS(expr, ...) ((void)0) -#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) ((void)0) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_THROWS_AS(expr, ex) ((void)0) -#define DOCTEST_CHECK_THROWS_AS(expr, ex) ((void)0) -#define DOCTEST_REQUIRE_THROWS_AS(expr, ex) ((void)0) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_NOTHROW(expr) ((void)0) -#define DOCTEST_CHECK_NOTHROW(expr) ((void)0) -#define DOCTEST_REQUIRE_NOTHROW(expr) ((void)0) - -#define DOCTEST_WARN_THROWS_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_CHECK_THROWS_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0) -#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0) -#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0) -#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, msg) ((void)0) - -#else // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS - -#undef DOCTEST_REQUIRE -#undef DOCTEST_REQUIRE_FALSE -#undef DOCTEST_REQUIRE_MESSAGE -#undef DOCTEST_REQUIRE_FALSE_MESSAGE -#undef DOCTEST_REQUIRE_EQ -#undef DOCTEST_REQUIRE_NE -#undef DOCTEST_REQUIRE_GT -#undef DOCTEST_REQUIRE_LT -#undef DOCTEST_REQUIRE_GE -#undef DOCTEST_REQUIRE_LE -#undef DOCTEST_REQUIRE_UNARY -#undef DOCTEST_REQUIRE_UNARY_FALSE -#undef DOCTEST_FAST_REQUIRE_EQ -#undef DOCTEST_FAST_REQUIRE_NE -#undef DOCTEST_FAST_REQUIRE_GT -#undef DOCTEST_FAST_REQUIRE_LT -#undef DOCTEST_FAST_REQUIRE_GE -#undef DOCTEST_FAST_REQUIRE_LE -#undef DOCTEST_FAST_REQUIRE_UNARY -#undef DOCTEST_FAST_REQUIRE_UNARY_FALSE - -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS - -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - -// ================================================================================================= -// == WHAT FOLLOWS IS VERSIONS OF THE MACROS THAT DO NOT DO ANY REGISTERING! == -// == THIS CAN BE ENABLED BY DEFINING DOCTEST_CONFIG_DISABLE GLOBALLY! == -// ================================================================================================= -#else // DOCTEST_CONFIG_DISABLE - -#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, name) \ - namespace \ - { \ - template \ - struct der : base \ - { void f(); }; \ - } \ - template \ - inline void der::f() - -#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, name) \ - template \ - static inline void f() - -// for registering tests -#define DOCTEST_TEST_CASE(name) \ - DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name) - -// for registering tests with a fixture -#define DOCTEST_TEST_CASE_FIXTURE(x, name) \ - DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(_DOCTEST_ANON_CLASS_), x, \ - DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name) - -// for converting types to strings without the header and demangling -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TYPE_TO_STRING(...) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) -#define DOCTEST_TYPE_TO_STRING_IMPL(...) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_TYPE_TO_STRING(x) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) -#define DOCTEST_TYPE_TO_STRING_IMPL(x) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -// for typed tests -#define DOCTEST_TEST_CASE_TEMPLATE(name, type, types) \ - template \ - inline void DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)() - -#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, type, id) \ - template \ - inline void DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)() - -#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, types) \ - typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) - -// for subcases -#define DOCTEST_SUBCASE(name) - -// for a testsuite block -#define DOCTEST_TEST_SUITE(name) namespace - -// for starting a testsuite block -#define DOCTEST_TEST_SUITE_BEGIN(name) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) - -// for ending a testsuite block -#define DOCTEST_TEST_SUITE_END typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) - -#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) \ - template \ - static inline doctest::String DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_)(signature) - -#define DOCTEST_INFO(x) ((void)0) -#define DOCTEST_CAPTURE(x) ((void)0) -#define DOCTEST_ADD_MESSAGE_AT(file, line, x) ((void)0) -#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, x) ((void)0) -#define DOCTEST_ADD_FAIL_AT(file, line, x) ((void)0) -#define DOCTEST_MESSAGE(x) ((void)0) -#define DOCTEST_FAIL_CHECK(x) ((void)0) -#define DOCTEST_FAIL(x) ((void)0) - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN(...) ((void)0) -#define DOCTEST_CHECK(...) ((void)0) -#define DOCTEST_REQUIRE(...) ((void)0) -#define DOCTEST_WARN_FALSE(...) ((void)0) -#define DOCTEST_CHECK_FALSE(...) ((void)0) -#define DOCTEST_REQUIRE_FALSE(...) ((void)0) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN(expr) ((void)0) -#define DOCTEST_CHECK(expr) ((void)0) -#define DOCTEST_REQUIRE(expr) ((void)0) -#define DOCTEST_WARN_FALSE(expr) ((void)0) -#define DOCTEST_CHECK_FALSE(expr) ((void)0) -#define DOCTEST_REQUIRE_FALSE(expr) ((void)0) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_WARN_MESSAGE(cond, msg) ((void)0) -#define DOCTEST_CHECK_MESSAGE(cond, msg) ((void)0) -#define DOCTEST_REQUIRE_MESSAGE(cond, msg) ((void)0) -#define DOCTEST_WARN_FALSE_MESSAGE(cond, msg) ((void)0) -#define DOCTEST_CHECK_FALSE_MESSAGE(cond, msg) ((void)0) -#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, msg) ((void)0) - -#define DOCTEST_WARN_THROWS(expr) ((void)0) -#define DOCTEST_CHECK_THROWS(expr) ((void)0) -#define DOCTEST_REQUIRE_THROWS(expr) ((void)0) -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_THROWS_AS(expr, ...) ((void)0) -#define DOCTEST_CHECK_THROWS_AS(expr, ...) ((void)0) -#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) ((void)0) -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_THROWS_AS(expr, ex) ((void)0) -#define DOCTEST_CHECK_THROWS_AS(expr, ex) ((void)0) -#define DOCTEST_REQUIRE_THROWS_AS(expr, ex) ((void)0) -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS -#define DOCTEST_WARN_NOTHROW(expr) ((void)0) -#define DOCTEST_CHECK_NOTHROW(expr) ((void)0) -#define DOCTEST_REQUIRE_NOTHROW(expr) ((void)0) - -#define DOCTEST_WARN_THROWS_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_CHECK_THROWS_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0) -#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0) -#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0) -#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, msg) ((void)0) -#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, msg) ((void)0) - -#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_WARN_EQ(...) ((void)0) -#define DOCTEST_CHECK_EQ(...) ((void)0) -#define DOCTEST_REQUIRE_EQ(...) ((void)0) -#define DOCTEST_WARN_NE(...) ((void)0) -#define DOCTEST_CHECK_NE(...) ((void)0) -#define DOCTEST_REQUIRE_NE(...) ((void)0) -#define DOCTEST_WARN_GT(...) ((void)0) -#define DOCTEST_CHECK_GT(...) ((void)0) -#define DOCTEST_REQUIRE_GT(...) ((void)0) -#define DOCTEST_WARN_LT(...) ((void)0) -#define DOCTEST_CHECK_LT(...) ((void)0) -#define DOCTEST_REQUIRE_LT(...) ((void)0) -#define DOCTEST_WARN_GE(...) ((void)0) -#define DOCTEST_CHECK_GE(...) ((void)0) -#define DOCTEST_REQUIRE_GE(...) ((void)0) -#define DOCTEST_WARN_LE(...) ((void)0) -#define DOCTEST_CHECK_LE(...) ((void)0) -#define DOCTEST_REQUIRE_LE(...) ((void)0) - -#define DOCTEST_WARN_UNARY(...) ((void)0) -#define DOCTEST_CHECK_UNARY(...) ((void)0) -#define DOCTEST_REQUIRE_UNARY(...) ((void)0) -#define DOCTEST_WARN_UNARY_FALSE(...) ((void)0) -#define DOCTEST_CHECK_UNARY_FALSE(...) ((void)0) -#define DOCTEST_REQUIRE_UNARY_FALSE(...) ((void)0) - -#define DOCTEST_FAST_WARN_EQ(...) ((void)0) -#define DOCTEST_FAST_CHECK_EQ(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_EQ(...) ((void)0) -#define DOCTEST_FAST_WARN_NE(...) ((void)0) -#define DOCTEST_FAST_CHECK_NE(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_NE(...) ((void)0) -#define DOCTEST_FAST_WARN_GT(...) ((void)0) -#define DOCTEST_FAST_CHECK_GT(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_GT(...) ((void)0) -#define DOCTEST_FAST_WARN_LT(...) ((void)0) -#define DOCTEST_FAST_CHECK_LT(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_LT(...) ((void)0) -#define DOCTEST_FAST_WARN_GE(...) ((void)0) -#define DOCTEST_FAST_CHECK_GE(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_GE(...) ((void)0) -#define DOCTEST_FAST_WARN_LE(...) ((void)0) -#define DOCTEST_FAST_CHECK_LE(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_LE(...) ((void)0) - -#define DOCTEST_FAST_WARN_UNARY(...) ((void)0) -#define DOCTEST_FAST_CHECK_UNARY(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_UNARY(...) ((void)0) -#define DOCTEST_FAST_WARN_UNARY_FALSE(...) ((void)0) -#define DOCTEST_FAST_CHECK_UNARY_FALSE(...) ((void)0) -#define DOCTEST_FAST_REQUIRE_UNARY_FALSE(...) ((void)0) - -#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#define DOCTEST_WARN_EQ(lhs, rhs) ((void)0) -#define DOCTEST_CHECK_EQ(lhs, rhs) ((void)0) -#define DOCTEST_REQUIRE_EQ(lhs, rhs) ((void)0) -#define DOCTEST_WARN_NE(lhs, rhs) ((void)0) -#define DOCTEST_CHECK_NE(lhs, rhs) ((void)0) -#define DOCTEST_REQUIRE_NE(lhs, rhs) ((void)0) -#define DOCTEST_WARN_GT(lhs, rhs) ((void)0) -#define DOCTEST_CHECK_GT(lhs, rhs) ((void)0) -#define DOCTEST_REQUIRE_GT(lhs, rhs) ((void)0) -#define DOCTEST_WARN_LT(lhs, rhs) ((void)0) -#define DOCTEST_CHECK_LT(lhs, rhs) ((void)0) -#define DOCTEST_REQUIRE_LT(lhs, rhs) ((void)0) -#define DOCTEST_WARN_GE(lhs, rhs) ((void)0) -#define DOCTEST_CHECK_GE(lhs, rhs) ((void)0) -#define DOCTEST_REQUIRE_GE(lhs, rhs) ((void)0) -#define DOCTEST_WARN_LE(lhs, rhs) ((void)0) -#define DOCTEST_CHECK_LE(lhs, rhs) ((void)0) -#define DOCTEST_REQUIRE_LE(lhs, rhs) ((void)0) - -#define DOCTEST_WARN_UNARY(val) ((void)0) -#define DOCTEST_CHECK_UNARY(val) ((void)0) -#define DOCTEST_REQUIRE_UNARY(val) ((void)0) -#define DOCTEST_WARN_UNARY_FALSE(val) ((void)0) -#define DOCTEST_CHECK_UNARY_FALSE(val) ((void)0) -#define DOCTEST_REQUIRE_UNARY_FALSE(val) ((void)0) - -#define DOCTEST_FAST_WARN_EQ(lhs, rhs) ((void)0) -#define DOCTEST_FAST_CHECK_EQ(lhs, rhs) ((void)0) -#define DOCTEST_FAST_REQUIRE_EQ(lhs, rhs) ((void)0) -#define DOCTEST_FAST_WARN_NE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_CHECK_NE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_REQUIRE_NE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_WARN_GT(lhs, rhs) ((void)0) -#define DOCTEST_FAST_CHECK_GT(lhs, rhs) ((void)0) -#define DOCTEST_FAST_REQUIRE_GT(lhs, rhs) ((void)0) -#define DOCTEST_FAST_WARN_LT(lhs, rhs) ((void)0) -#define DOCTEST_FAST_CHECK_LT(lhs, rhs) ((void)0) -#define DOCTEST_FAST_REQUIRE_LT(lhs, rhs) ((void)0) -#define DOCTEST_FAST_WARN_GE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_CHECK_GE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_REQUIRE_GE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_WARN_LE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_CHECK_LE(lhs, rhs) ((void)0) -#define DOCTEST_FAST_REQUIRE_LE(lhs, rhs) ((void)0) - -#define DOCTEST_FAST_WARN_UNARY(val) ((void)0) -#define DOCTEST_FAST_CHECK_UNARY(val) ((void)0) -#define DOCTEST_FAST_REQUIRE_UNARY(val) ((void)0) -#define DOCTEST_FAST_WARN_UNARY_FALSE(val) ((void)0) -#define DOCTEST_FAST_CHECK_UNARY_FALSE(val) ((void)0) -#define DOCTEST_FAST_REQUIRE_UNARY_FALSE(val) ((void)0) - -#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS - -#endif // DOCTEST_CONFIG_DISABLE - -// BDD style macros -// clang-format off -#define DOCTEST_SCENARIO(name) TEST_CASE(" Scenario: " name) -#define DOCTEST_GIVEN(name) SUBCASE(" Given: " name) -#define DOCTEST_WHEN(name) SUBCASE(" When: " name) -#define DOCTEST_AND_WHEN(name) SUBCASE("And when: " name) -#define DOCTEST_THEN(name) SUBCASE(" Then: " name) -#define DOCTEST_AND_THEN(name) SUBCASE(" And: " name) -// clang-format on - -// == SHORT VERSIONS OF THE MACROS -#if !defined(DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES) - -#define TEST_CASE DOCTEST_TEST_CASE -#define TEST_CASE_FIXTURE DOCTEST_TEST_CASE_FIXTURE -#define TYPE_TO_STRING DOCTEST_TYPE_TO_STRING -#define TEST_CASE_TEMPLATE DOCTEST_TEST_CASE_TEMPLATE -#define TEST_CASE_TEMPLATE_DEFINE DOCTEST_TEST_CASE_TEMPLATE_DEFINE -#define TEST_CASE_TEMPLATE_INSTANTIATE DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE -#define SUBCASE DOCTEST_SUBCASE -#define TEST_SUITE DOCTEST_TEST_SUITE -#define TEST_SUITE_BEGIN DOCTEST_TEST_SUITE_BEGIN -#define TEST_SUITE_END DOCTEST_TEST_SUITE_END -#define REGISTER_EXCEPTION_TRANSLATOR DOCTEST_REGISTER_EXCEPTION_TRANSLATOR -#define INFO DOCTEST_INFO -#define CAPTURE DOCTEST_CAPTURE -#define ADD_MESSAGE_AT DOCTEST_ADD_MESSAGE_AT -#define ADD_FAIL_CHECK_AT DOCTEST_ADD_FAIL_CHECK_AT -#define ADD_FAIL_AT DOCTEST_ADD_FAIL_AT -#define MESSAGE DOCTEST_MESSAGE -#define FAIL_CHECK DOCTEST_FAIL_CHECK -#define FAIL DOCTEST_FAIL -#define TO_LVALUE DOCTEST_TO_LVALUE - -#define WARN DOCTEST_WARN -#define WARN_FALSE DOCTEST_WARN_FALSE -#define WARN_THROWS DOCTEST_WARN_THROWS -#define WARN_THROWS_AS DOCTEST_WARN_THROWS_AS -#define WARN_NOTHROW DOCTEST_WARN_NOTHROW -#define CHECK DOCTEST_CHECK -#define CHECK_FALSE DOCTEST_CHECK_FALSE -#define CHECK_THROWS DOCTEST_CHECK_THROWS -#define CHECK_THROWS_AS DOCTEST_CHECK_THROWS_AS -#define CHECK_NOTHROW DOCTEST_CHECK_NOTHROW -#define REQUIRE DOCTEST_REQUIRE -#define REQUIRE_FALSE DOCTEST_REQUIRE_FALSE -#define REQUIRE_THROWS DOCTEST_REQUIRE_THROWS -#define REQUIRE_THROWS_AS DOCTEST_REQUIRE_THROWS_AS -#define REQUIRE_NOTHROW DOCTEST_REQUIRE_NOTHROW - -#define WARN_MESSAGE DOCTEST_WARN_MESSAGE -#define WARN_FALSE_MESSAGE DOCTEST_WARN_FALSE_MESSAGE -#define WARN_THROWS_MESSAGE DOCTEST_WARN_THROWS_MESSAGE -#define WARN_THROWS_AS_MESSAGE DOCTEST_WARN_THROWS_AS_MESSAGE -#define WARN_NOTHROW_MESSAGE DOCTEST_WARN_NOTHROW_MESSAGE -#define CHECK_MESSAGE DOCTEST_CHECK_MESSAGE -#define CHECK_FALSE_MESSAGE DOCTEST_CHECK_FALSE_MESSAGE -#define CHECK_THROWS_MESSAGE DOCTEST_CHECK_THROWS_MESSAGE -#define CHECK_THROWS_AS_MESSAGE DOCTEST_CHECK_THROWS_AS_MESSAGE -#define CHECK_NOTHROW_MESSAGE DOCTEST_CHECK_NOTHROW_MESSAGE -#define REQUIRE_MESSAGE DOCTEST_REQUIRE_MESSAGE -#define REQUIRE_FALSE_MESSAGE DOCTEST_REQUIRE_FALSE_MESSAGE -#define REQUIRE_THROWS_MESSAGE DOCTEST_REQUIRE_THROWS_MESSAGE -#define REQUIRE_THROWS_AS_MESSAGE DOCTEST_REQUIRE_THROWS_AS_MESSAGE -#define REQUIRE_NOTHROW_MESSAGE DOCTEST_REQUIRE_NOTHROW_MESSAGE - -#define SCENARIO DOCTEST_SCENARIO -#define GIVEN DOCTEST_GIVEN -#define WHEN DOCTEST_WHEN -#define AND_WHEN DOCTEST_AND_WHEN -#define THEN DOCTEST_THEN -#define AND_THEN DOCTEST_AND_THEN - -#define WARN_EQ DOCTEST_WARN_EQ -#define CHECK_EQ DOCTEST_CHECK_EQ -#define REQUIRE_EQ DOCTEST_REQUIRE_EQ -#define WARN_NE DOCTEST_WARN_NE -#define CHECK_NE DOCTEST_CHECK_NE -#define REQUIRE_NE DOCTEST_REQUIRE_NE -#define WARN_GT DOCTEST_WARN_GT -#define CHECK_GT DOCTEST_CHECK_GT -#define REQUIRE_GT DOCTEST_REQUIRE_GT -#define WARN_LT DOCTEST_WARN_LT -#define CHECK_LT DOCTEST_CHECK_LT -#define REQUIRE_LT DOCTEST_REQUIRE_LT -#define WARN_GE DOCTEST_WARN_GE -#define CHECK_GE DOCTEST_CHECK_GE -#define REQUIRE_GE DOCTEST_REQUIRE_GE -#define WARN_LE DOCTEST_WARN_LE -#define CHECK_LE DOCTEST_CHECK_LE -#define REQUIRE_LE DOCTEST_REQUIRE_LE -#define WARN_UNARY DOCTEST_WARN_UNARY -#define CHECK_UNARY DOCTEST_CHECK_UNARY -#define REQUIRE_UNARY DOCTEST_REQUIRE_UNARY -#define WARN_UNARY_FALSE DOCTEST_WARN_UNARY_FALSE -#define CHECK_UNARY_FALSE DOCTEST_CHECK_UNARY_FALSE -#define REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE - -#define FAST_WARN_EQ DOCTEST_FAST_WARN_EQ -#define FAST_CHECK_EQ DOCTEST_FAST_CHECK_EQ -#define FAST_REQUIRE_EQ DOCTEST_FAST_REQUIRE_EQ -#define FAST_WARN_NE DOCTEST_FAST_WARN_NE -#define FAST_CHECK_NE DOCTEST_FAST_CHECK_NE -#define FAST_REQUIRE_NE DOCTEST_FAST_REQUIRE_NE -#define FAST_WARN_GT DOCTEST_FAST_WARN_GT -#define FAST_CHECK_GT DOCTEST_FAST_CHECK_GT -#define FAST_REQUIRE_GT DOCTEST_FAST_REQUIRE_GT -#define FAST_WARN_LT DOCTEST_FAST_WARN_LT -#define FAST_CHECK_LT DOCTEST_FAST_CHECK_LT -#define FAST_REQUIRE_LT DOCTEST_FAST_REQUIRE_LT -#define FAST_WARN_GE DOCTEST_FAST_WARN_GE -#define FAST_CHECK_GE DOCTEST_FAST_CHECK_GE -#define FAST_REQUIRE_GE DOCTEST_FAST_REQUIRE_GE -#define FAST_WARN_LE DOCTEST_FAST_WARN_LE -#define FAST_CHECK_LE DOCTEST_FAST_CHECK_LE -#define FAST_REQUIRE_LE DOCTEST_FAST_REQUIRE_LE -#define FAST_WARN_UNARY DOCTEST_FAST_WARN_UNARY -#define FAST_CHECK_UNARY DOCTEST_FAST_CHECK_UNARY -#define FAST_REQUIRE_UNARY DOCTEST_FAST_REQUIRE_UNARY -#define FAST_WARN_UNARY_FALSE DOCTEST_FAST_WARN_UNARY_FALSE -#define FAST_CHECK_UNARY_FALSE DOCTEST_FAST_CHECK_UNARY_FALSE -#define FAST_REQUIRE_UNARY_FALSE DOCTEST_FAST_REQUIRE_UNARY_FALSE - -#endif // DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES - -// this is here to clear the 'current test suite' for the current translation unit - at the top -DOCTEST_TEST_SUITE_END(); - -// add stringification for primitive/fundamental types -namespace doctest -{ -namespace detail -{ - DOCTEST_TYPE_TO_STRING_IMPL(bool) - DOCTEST_TYPE_TO_STRING_IMPL(float) - DOCTEST_TYPE_TO_STRING_IMPL(double) - DOCTEST_TYPE_TO_STRING_IMPL(long double) - DOCTEST_TYPE_TO_STRING_IMPL(char) - DOCTEST_TYPE_TO_STRING_IMPL(signed char) - DOCTEST_TYPE_TO_STRING_IMPL(unsigned char) - DOCTEST_TYPE_TO_STRING_IMPL(wchar_t) - DOCTEST_TYPE_TO_STRING_IMPL(short int) - DOCTEST_TYPE_TO_STRING_IMPL(unsigned short int) - DOCTEST_TYPE_TO_STRING_IMPL(int) - DOCTEST_TYPE_TO_STRING_IMPL(unsigned int) - DOCTEST_TYPE_TO_STRING_IMPL(long int) - DOCTEST_TYPE_TO_STRING_IMPL(unsigned long int) -#ifdef DOCTEST_CONFIG_WITH_LONG_LONG - DOCTEST_TYPE_TO_STRING_IMPL(long long int) - DOCTEST_TYPE_TO_STRING_IMPL(unsigned long long int) -#endif // DOCTEST_CONFIG_WITH_LONG_LONG -} // namespace detail -} // namespace doctest - -#endif // DOCTEST_LIBRARY_INCLUDED - -#if defined(__clang__) -#pragma clang diagnostic pop -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic pop -#endif // > gcc 4.6 -#endif // __GNUC__ - -#ifdef _MSC_VER -#pragma warning(pop) -#endif // _MSC_VER - -#ifndef DOCTEST_SINGLE_HEADER -#define DOCTEST_SINGLE_HEADER -#endif // DOCTEST_SINGLE_HEADER - -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunknown-pragmas" -#pragma clang diagnostic ignored "-Wpadded" -#pragma clang diagnostic ignored "-Wglobal-constructors" -#pragma clang diagnostic ignored "-Wexit-time-destructors" -#pragma clang diagnostic ignored "-Wmissing-prototypes" -#pragma clang diagnostic ignored "-Wsign-conversion" -#pragma clang diagnostic ignored "-Wshorten-64-to-32" -#pragma clang diagnostic ignored "-Wmissing-variable-declarations" -#pragma clang diagnostic ignored "-Wswitch" -#pragma clang diagnostic ignored "-Wswitch-enum" -#pragma clang diagnostic ignored "-Wcovered-switch-default" -#pragma clang diagnostic ignored "-Wmissing-noreturn" -#pragma clang diagnostic ignored "-Wunused-local-typedef" -#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" -#pragma clang diagnostic ignored "-Wmissing-braces" -#pragma clang diagnostic ignored "-Wmissing-field-initializers" -#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" -#pragma clang diagnostic ignored "-Wc++11-long-long" -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic push -#endif // > gcc 4.6 -#pragma GCC diagnostic ignored "-Wunknown-pragmas" -#pragma GCC diagnostic ignored "-Wconversion" -#pragma GCC diagnostic ignored "-Weffc++" -#pragma GCC diagnostic ignored "-Wsign-conversion" -#pragma GCC diagnostic ignored "-Wstrict-overflow" -#pragma GCC diagnostic ignored "-Wmissing-field-initializers" -#pragma GCC diagnostic ignored "-Wmissing-braces" -#pragma GCC diagnostic ignored "-Wmissing-declarations" -#pragma GCC diagnostic ignored "-Winline" -#pragma GCC diagnostic ignored "-Wswitch" -#pragma GCC diagnostic ignored "-Wswitch-enum" -#pragma GCC diagnostic ignored "-Wswitch-default" -#pragma GCC diagnostic ignored "-Wunsafe-loop-optimizations" -#pragma GCC diagnostic ignored "-Wlong-long" -#pragma GCC diagnostic ignored "-Wold-style-cast" -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" -#endif // > gcc 4.6 -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 7) -#pragma GCC diagnostic ignored "-Wunused-local-typedefs" -#endif // > gcc 4.7 -#if __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3) -#pragma GCC diagnostic ignored "-Wuseless-cast" -#endif // > gcc 5.3 -#endif // __GNUC__ - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable : 4996) // The compiler encountered a deprecated declaration -#pragma warning(disable : 4267) // 'var' : conversion from 'size_t' to 'type', possible loss of data -#pragma warning(disable : 4706) // assignment within conditional expression -#pragma warning(disable : 4512) // 'class' : assignment operator could not be generated -#pragma warning(disable : 4127) // conditional expression is constant -#pragma warning(disable : 4530) // C++ exception handler used, but unwind semantics are not enabled -#pragma warning(disable : 4577) // 'noexcept' used with no exception handling mode specified -#endif // _MSC_VER - -#if defined(DOCTEST_CONFIG_IMPLEMENT) || !defined(DOCTEST_SINGLE_HEADER) -#ifndef DOCTEST_LIBRARY_IMPLEMENTATION -#define DOCTEST_LIBRARY_IMPLEMENTATION - -#ifndef DOCTEST_SINGLE_HEADER -#include "doctest_fwd.h" -#endif // DOCTEST_SINGLE_HEADER - -#if defined(__clang__) && defined(DOCTEST_NO_CPP11_COMPAT) -#pragma clang diagnostic ignored "-Wc++98-compat" -#pragma clang diagnostic ignored "-Wc++98-compat-pedantic" -#endif // __clang__ && DOCTEST_NO_CPP11_COMPAT - -// snprintf() not in the C++98 standard -#ifdef _MSC_VER -#define DOCTEST_SNPRINTF _snprintf -#else -#define DOCTEST_SNPRINTF std::snprintf -#endif - -#define DOCTEST_LOG_START() \ - do { \ - if(!contextState->hasLoggedCurrentTestStart) { \ - doctest::detail::logTestStart(*contextState->currentTest); \ - contextState->hasLoggedCurrentTestStart = true; \ - } \ - } while(false) - -// required includes - will go only in one translation unit! -#include -#include -// borland (Embarcadero) compiler requires math.h and not cmath - https://github.com/onqtam/doctest/pull/37 -#ifdef __BORLANDC__ -#include -#endif // __BORLANDC__ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifndef _MSC_VER -#include -#endif // _MSC_VER - -namespace doctest -{ -namespace detail -{ - // lowers ascii letters - char tolower(const char c) { return (c >= 'A' && c <= 'Z') ? static_cast(c + 32) : c; } - - template - T my_max(const T& lhs, const T& rhs) { - return lhs > rhs ? lhs : rhs; - } - - // case insensitive strcmp - int stricmp(char const* a, char const* b) { - for(;; a++, b++) { - int d = tolower(*a) - tolower(*b); - if(d != 0 || !*a) - return d; - } - } - - void my_memcpy(void* dest, const void* src, unsigned num) { - const char* csrc = static_cast(src); - char* cdest = static_cast(dest); - for(unsigned i = 0; i < num; ++i) - cdest[i] = csrc[i]; - } - - // not using std::strlen() because of valgrind errors when optimizations are turned on - // 'Invalid read of size 4' when the test suite len (with '\0') is not a multiple of 4 - // for details see http://stackoverflow.com/questions/35671155 - unsigned my_strlen(const char* in) { - const char* temp = in; - while(temp && *temp) - ++temp; - return unsigned(temp - in); - } - - template - String fpToString(T value, int precision) { - std::ostringstream oss; - oss << std::setprecision(precision) << std::fixed << value; - std::string d = oss.str(); - size_t i = d.find_last_not_of('0'); - if(i != std::string::npos && i != d.size() - 1) { - if(d[i] == '.') - i++; - d = d.substr(0, i + 1); - } - return d.c_str(); - } - - struct Endianness - { - enum Arch - { - Big, - Little - }; - - static Arch which() { - union _ - { - int asInt; - char asChar[sizeof(int)]; - } u; - - u.asInt = 1; // NOLINT - return (u.asChar[sizeof(int) - 1] == 1) ? Big : Little; // NOLINT - } - }; - - String rawMemoryToString(const void* object, unsigned size) { - // Reverse order for little endian architectures - int i = 0, end = static_cast(size), inc = 1; - if(Endianness::which() == Endianness::Little) { - i = end - 1; - end = inc = -1; - } - - unsigned char const* bytes = static_cast(object); - std::ostringstream os; - os << "0x" << std::setfill('0') << std::hex; - for(; i != end; i += inc) - os << std::setw(2) << static_cast(bytes[i]); - return os.str().c_str(); - } - - std::ostream* createStream() { return new std::ostringstream(); } - String getStreamResult(std::ostream* in) { - return static_cast(in)->str().c_str(); // NOLINT - } - void freeStream(std::ostream* in) { delete in; } - -#ifndef DOCTEST_CONFIG_DISABLE - - // this holds both parameters for the command line and runtime data for tests - struct ContextState : TestAccessibleContextState //!OCLINT too many fields - { - // == parameters from the command line - - std::vector > filters; - - String order_by; // how tests should be ordered - unsigned rand_seed; // the seed for rand ordering - - unsigned first; // the first (matching) test to be executed - unsigned last; // the last (matching) test to be executed - - int abort_after; // stop tests after this many failed assertions - int subcase_filter_levels; // apply the subcase filters for the first N levels - bool case_sensitive; // if filtering should be case sensitive - bool exit; // if the program should be exited after the tests are ran/whatever - bool duration; // print the time duration of each test case - bool no_exitcode; // if the framework should return 0 as the exitcode - bool no_run; // to not run the tests at all (can be done with an "*" exclude) - bool no_version; // to not print the version of the framework - bool no_colors; // if output to the console should be colorized - bool force_colors; // forces the use of colors even when a tty cannot be detected - bool no_breaks; // to not break into the debugger - bool no_skip; // don't skip test cases which are marked to be skipped - bool no_path_in_filenames; // if the path to files should be removed from the output - bool no_line_numbers; // if source code line numbers should be omitted from the output - bool no_skipped_summary; // don't print "skipped" in the summary !!! UNDOCUMENTED !!! - - bool help; // to print the help - bool version; // to print the version - bool count; // if only the count of matching tests is to be retreived - bool list_test_cases; // to list all tests matching the filters - bool list_test_suites; // to list all suites matching the filters - - // == data for the tests being ran - - unsigned numTestsPassingFilters; - unsigned numTestSuitesPassingFilters; - unsigned numFailed; - const TestCase* currentTest; - bool hasLoggedCurrentTestStart; - int numAssertionsForCurrentTestcase; - int numAssertions; - int numFailedAssertionsForCurrentTestcase; - int numFailedAssertions; - bool hasCurrentTestFailed; - - std::vector contexts; // for logging with INFO() and friends - std::vector exceptionalContexts; // logging from INFO() due to an exception - - // stuff for subcases - std::set subcasesPassed; - std::set subcasesEnteredLevels; - std::vector subcasesStack; - int subcasesCurrentLevel; - bool subcasesHasSkipped; - - void resetRunData() { - numTestsPassingFilters = 0; - numTestSuitesPassingFilters = 0; - numFailed = 0; - numAssertions = 0; - numFailedAssertions = 0; - numFailedAssertionsForCurrentTestcase = 0; - } - - // cppcheck-suppress uninitMemberVar - ContextState() - : filters(8) // 8 different filters total - { - resetRunData(); - } - }; - - ContextState* contextState = 0; -#endif // DOCTEST_CONFIG_DISABLE -} // namespace detail - -void String::copy(const String& other) { - if(other.isOnStack()) { - detail::my_memcpy(buf, other.buf, len); - } else { - setOnHeap(); - data.size = other.data.size; - data.capacity = data.size + 1; - data.ptr = new char[data.capacity]; - detail::my_memcpy(data.ptr, other.data.ptr, data.size + 1); - } -} - -String::String(const char* in) { - unsigned in_len = detail::my_strlen(in); - if(in_len <= last) { - detail::my_memcpy(buf, in, in_len + 1); - setLast(last - in_len); - } else { - setOnHeap(); - data.size = in_len; - data.capacity = data.size + 1; - data.ptr = new char[data.capacity]; - detail::my_memcpy(data.ptr, in, in_len + 1); - } -} - -String& String::operator+=(const String& other) { - unsigned my_old_size = size(); - unsigned other_size = other.size(); - unsigned total_size = my_old_size + other_size; - if(isOnStack()) { - if(total_size < len) { - // append to the current stack space - detail::my_memcpy(buf + my_old_size, other.c_str(), other_size + 1); - setLast(last - total_size); - } else { - // alloc new chunk - char* temp = new char[total_size + 1]; - // copy current data to new location before writing in the union - detail::my_memcpy(temp, buf, my_old_size); // skip the +1 ('\0') for speed - // update data in union - setOnHeap(); - data.size = total_size; - data.capacity = data.size + 1; - data.ptr = temp; - // transfer the rest of the data - detail::my_memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1); - } - } else { - if(data.capacity > total_size) { - // append to the current heap block - data.size = total_size; - detail::my_memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1); - } else { - // resize - data.capacity *= 2; - if(data.capacity <= total_size) - data.capacity = total_size + 1; - // alloc new chunk - char* temp = new char[data.capacity]; - // copy current data to new location before releasing it - detail::my_memcpy(temp, data.ptr, my_old_size); // skip the +1 ('\0') for speed - // release old chunk - delete[] data.ptr; - // update the rest of the union members - data.size = total_size; - data.ptr = temp; - // transfer the rest of the data - detail::my_memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1); - } - } - - return *this; -} - -#ifdef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES -String::String(String&& other) { - detail::my_memcpy(buf, other.buf, len); - other.buf[0] = '\0'; - other.setLast(); -} - -String& String::operator=(String&& other) { - if(!isOnStack()) - delete[] data.ptr; - detail::my_memcpy(buf, other.buf, len); - other.buf[0] = '\0'; - other.setLast(); - return *this; -} -#endif // DOCTEST_CONFIG_WITH_RVALUE_REFERENCES - -int String::compare(const char* other, bool no_case) const { - if(no_case) - return detail::stricmp(c_str(), other); - return std::strcmp(c_str(), other); -} - -int String::compare(const String& other, bool no_case) const { - return compare(other.c_str(), no_case); -} - -std::ostream& operator<<(std::ostream& stream, const String& in) { - stream << in.c_str(); - return stream; -} - -Approx::Approx(double value) - : m_epsilon(static_cast(std::numeric_limits::epsilon()) * 100) - , m_scale(1.0) - , m_value(value) {} - -bool operator==(double lhs, Approx const& rhs) { - // Thanks to Richard Harris for his help refining this formula - return std::fabs(lhs - rhs.m_value) < - rhs.m_epsilon * (rhs.m_scale + detail::my_max(std::fabs(lhs), std::fabs(rhs.m_value))); -} - -String Approx::toString() const { return String("Approx( ") + doctest::toString(m_value) + " )"; } - -#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -String toString(char* in) { return toString(static_cast(in)); } -String toString(const char* in) { return String("\"") + (in ? in : "{null string}") + "\""; } -#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING -String toString(bool in) { return in ? "true" : "false"; } -String toString(float in) { return detail::fpToString(in, 5) + "f"; } -String toString(double in) { return detail::fpToString(in, 10); } -String toString(double long in) { return detail::fpToString(in, 15); } - -String toString(char in) { - char buf[64]; - std::sprintf(buf, "%d", in); - return buf; -} - -String toString(char signed in) { - char buf[64]; - std::sprintf(buf, "%d", in); - return buf; -} - -String toString(char unsigned in) { - char buf[64]; - std::sprintf(buf, "%ud", in); - return buf; -} - -String toString(int short in) { - char buf[64]; - std::sprintf(buf, "%d", in); - return buf; -} - -String toString(int short unsigned in) { - char buf[64]; - std::sprintf(buf, "%u", in); - return buf; -} - -String toString(int in) { - char buf[64]; - std::sprintf(buf, "%d", in); - return buf; -} - -String toString(int unsigned in) { - char buf[64]; - std::sprintf(buf, "%u", in); - return buf; -} - -String toString(int long in) { - char buf[64]; - std::sprintf(buf, "%ld", in); - return buf; -} - -String toString(int long unsigned in) { - char buf[64]; - std::sprintf(buf, "%lu", in); - return buf; -} - -#ifdef DOCTEST_CONFIG_WITH_LONG_LONG -String toString(int long long in) { - char buf[64]; - std::sprintf(buf, "%lld", in); - return buf; -} -String toString(int long long unsigned in) { - char buf[64]; - std::sprintf(buf, "%llu", in); - return buf; -} -#endif // DOCTEST_CONFIG_WITH_LONG_LONG - -#ifdef DOCTEST_CONFIG_WITH_NULLPTR -String toString(std::nullptr_t) { return "nullptr"; } -#endif // DOCTEST_CONFIG_WITH_NULLPTR - -} // namespace doctest - -#ifdef DOCTEST_CONFIG_DISABLE -namespace doctest -{ -bool isRunningInTest() { return false; } -Context::Context(int, const char* const*) {} -Context::~Context() {} -void Context::applyCommandLine(int, const char* const*) {} -void Context::addFilter(const char*, const char*) {} -void Context::clearFilters() {} -void Context::setOption(const char*, int) {} -void Context::setOption(const char*, const char*) {} -bool Context::shouldExit() { return false; } -int Context::run() { return 0; } -} // namespace doctest -#else // DOCTEST_CONFIG_DISABLE - -#if !defined(DOCTEST_CONFIG_COLORS_NONE) -#if !defined(DOCTEST_CONFIG_COLORS_WINDOWS) && !defined(DOCTEST_CONFIG_COLORS_ANSI) -#ifdef DOCTEST_PLATFORM_WINDOWS -#define DOCTEST_CONFIG_COLORS_WINDOWS -#else // linux -#define DOCTEST_CONFIG_COLORS_ANSI -#endif // platform -#endif // DOCTEST_CONFIG_COLORS_WINDOWS && DOCTEST_CONFIG_COLORS_ANSI -#endif // DOCTEST_CONFIG_COLORS_NONE - -#define DOCTEST_PRINTF_COLORED(buffer, color) \ - do { \ - doctest::detail::Color col(color); \ - std::printf("%s", buffer); \ - } while((void)0, 0) - -// the buffer size used for snprintf() calls -#if !defined(DOCTEST_SNPRINTF_BUFFER_LENGTH) -#define DOCTEST_SNPRINTF_BUFFER_LENGTH 1024 -#endif // DOCTEST_SNPRINTF_BUFFER_LENGTH - -#if defined(_MSC_VER) || defined(__MINGW32__) -#if defined(_MSC_VER) && _MSC_VER >= 1700 -#define DOCTEST_WINDOWS_SAL_IN_OPT _In_opt_ -#else // _MSC_VER -#define DOCTEST_WINDOWS_SAL_IN_OPT -#endif // _MSC_VER -extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( - DOCTEST_WINDOWS_SAL_IN_OPT const char*); -extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); -#endif // _MSC_VER || __MINGW32__ - -#ifdef DOCTEST_CONFIG_COLORS_ANSI -#include -#endif // DOCTEST_CONFIG_COLORS_ANSI - -#ifdef _WIN32 - -// defines for a leaner windows.h -#ifndef WIN32_MEAN_AND_LEAN -#define WIN32_MEAN_AND_LEAN -#endif // WIN32_MEAN_AND_LEAN -#ifndef VC_EXTRA_LEAN -#define VC_EXTRA_LEAN -#endif // VC_EXTRA_LEAN -#ifndef NOMINMAX -#define NOMINMAX -#endif // NOMINMAX - -// not sure what AfxWin.h is for - here I do what Catch does -#ifdef __AFXDLL -#include -#else -#include -#endif -#include - -#else // _WIN32 - -#include - -#endif // _WIN32 - -namespace doctest_detail_test_suite_ns -{ -// holds the current test suite -doctest::detail::TestSuite& getCurrentTestSuite() { - static doctest::detail::TestSuite data; - return data; -} -} // namespace doctest_detail_test_suite_ns - -namespace doctest -{ -namespace detail -{ - TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite, - const char* type, int template_id) - : m_test(test) - , m_name(0) - , m_type(type) - , m_test_suite(test_suite.m_test_suite) - , m_description(test_suite.m_description) - , m_skip(test_suite.m_skip) - , m_may_fail(test_suite.m_may_fail) - , m_should_fail(test_suite.m_should_fail) - , m_expected_failures(test_suite.m_expected_failures) - , m_timeout(test_suite.m_timeout) - , m_file(file) - , m_line(line) - , m_template_id(template_id) {} - - TestCase& TestCase::operator*(const char* in) { - m_name = in; - // make a new name with an appended type for templated test case - if(m_template_id != -1) { - m_full_name = String(m_name) + m_type; - // redirect the name to point to the newly constructed full name - m_name = m_full_name.c_str(); - } - return *this; - } - - TestCase& TestCase::operator=(const TestCase& other) { - m_test = other.m_test; - m_full_name = other.m_full_name; - m_name = other.m_name; - m_type = other.m_type; - m_test_suite = other.m_test_suite; - m_description = other.m_description; - m_skip = other.m_skip; - m_may_fail = other.m_may_fail; - m_should_fail = other.m_should_fail; - m_expected_failures = other.m_expected_failures; - m_timeout = other.m_timeout; - m_file = other.m_file; - m_line = other.m_line; - m_template_id = other.m_template_id; - - if(m_template_id != -1) - m_name = m_full_name.c_str(); - return *this; - } - - bool TestCase::operator<(const TestCase& other) const { - if(m_line != other.m_line) - return m_line < other.m_line; - int file_cmp = std::strcmp(m_file, other.m_file); - if(file_cmp != 0) - return file_cmp < 0; - return m_template_id < other.m_template_id; - } - - const char* getAssertString(assertType::Enum val) { - switch(val) { //!OCLINT missing default in switch statements - // clang-format off - case assertType::DT_WARN : return "WARN"; - case assertType::DT_CHECK : return "CHECK"; - case assertType::DT_REQUIRE : return "REQUIRE"; - - case assertType::DT_WARN_FALSE : return "WARN_FALSE"; - case assertType::DT_CHECK_FALSE : return "CHECK_FALSE"; - case assertType::DT_REQUIRE_FALSE : return "REQUIRE_FALSE"; - - case assertType::DT_WARN_THROWS : return "WARN_THROWS"; - case assertType::DT_CHECK_THROWS : return "CHECK_THROWS"; - case assertType::DT_REQUIRE_THROWS : return "REQUIRE_THROWS"; - - case assertType::DT_WARN_THROWS_AS : return "WARN_THROWS_AS"; - case assertType::DT_CHECK_THROWS_AS : return "CHECK_THROWS_AS"; - case assertType::DT_REQUIRE_THROWS_AS : return "REQUIRE_THROWS_AS"; - - case assertType::DT_WARN_NOTHROW : return "WARN_NOTHROW"; - case assertType::DT_CHECK_NOTHROW : return "CHECK_NOTHROW"; - case assertType::DT_REQUIRE_NOTHROW : return "REQUIRE_NOTHROW"; - - case assertType::DT_WARN_EQ : return "WARN_EQ"; - case assertType::DT_CHECK_EQ : return "CHECK_EQ"; - case assertType::DT_REQUIRE_EQ : return "REQUIRE_EQ"; - case assertType::DT_WARN_NE : return "WARN_NE"; - case assertType::DT_CHECK_NE : return "CHECK_NE"; - case assertType::DT_REQUIRE_NE : return "REQUIRE_NE"; - case assertType::DT_WARN_GT : return "WARN_GT"; - case assertType::DT_CHECK_GT : return "CHECK_GT"; - case assertType::DT_REQUIRE_GT : return "REQUIRE_GT"; - case assertType::DT_WARN_LT : return "WARN_LT"; - case assertType::DT_CHECK_LT : return "CHECK_LT"; - case assertType::DT_REQUIRE_LT : return "REQUIRE_LT"; - case assertType::DT_WARN_GE : return "WARN_GE"; - case assertType::DT_CHECK_GE : return "CHECK_GE"; - case assertType::DT_REQUIRE_GE : return "REQUIRE_GE"; - case assertType::DT_WARN_LE : return "WARN_LE"; - case assertType::DT_CHECK_LE : return "CHECK_LE"; - case assertType::DT_REQUIRE_LE : return "REQUIRE_LE"; - - case assertType::DT_WARN_UNARY : return "WARN_UNARY"; - case assertType::DT_CHECK_UNARY : return "CHECK_UNARY"; - case assertType::DT_REQUIRE_UNARY : return "REQUIRE_UNARY"; - case assertType::DT_WARN_UNARY_FALSE : return "WARN_UNARY_FALSE"; - case assertType::DT_CHECK_UNARY_FALSE : return "CHECK_UNARY_FALSE"; - case assertType::DT_REQUIRE_UNARY_FALSE : return "REQUIRE_UNARY_FALSE"; - - case assertType::DT_FAST_WARN_EQ : return "FAST_WARN_EQ"; - case assertType::DT_FAST_CHECK_EQ : return "FAST_CHECK_EQ"; - case assertType::DT_FAST_REQUIRE_EQ : return "FAST_REQUIRE_EQ"; - case assertType::DT_FAST_WARN_NE : return "FAST_WARN_NE"; - case assertType::DT_FAST_CHECK_NE : return "FAST_CHECK_NE"; - case assertType::DT_FAST_REQUIRE_NE : return "FAST_REQUIRE_NE"; - case assertType::DT_FAST_WARN_GT : return "FAST_WARN_GT"; - case assertType::DT_FAST_CHECK_GT : return "FAST_CHECK_GT"; - case assertType::DT_FAST_REQUIRE_GT : return "FAST_REQUIRE_GT"; - case assertType::DT_FAST_WARN_LT : return "FAST_WARN_LT"; - case assertType::DT_FAST_CHECK_LT : return "FAST_CHECK_LT"; - case assertType::DT_FAST_REQUIRE_LT : return "FAST_REQUIRE_LT"; - case assertType::DT_FAST_WARN_GE : return "FAST_WARN_GE"; - case assertType::DT_FAST_CHECK_GE : return "FAST_CHECK_GE"; - case assertType::DT_FAST_REQUIRE_GE : return "FAST_REQUIRE_GE"; - case assertType::DT_FAST_WARN_LE : return "FAST_WARN_LE"; - case assertType::DT_FAST_CHECK_LE : return "FAST_CHECK_LE"; - case assertType::DT_FAST_REQUIRE_LE : return "FAST_REQUIRE_LE"; - - case assertType::DT_FAST_WARN_UNARY : return "FAST_WARN_UNARY"; - case assertType::DT_FAST_CHECK_UNARY : return "FAST_CHECK_UNARY"; - case assertType::DT_FAST_REQUIRE_UNARY : return "FAST_REQUIRE_UNARY"; - case assertType::DT_FAST_WARN_UNARY_FALSE : return "FAST_WARN_UNARY_FALSE"; - case assertType::DT_FAST_CHECK_UNARY_FALSE : return "FAST_CHECK_UNARY_FALSE"; - case assertType::DT_FAST_REQUIRE_UNARY_FALSE: return "FAST_REQUIRE_UNARY_FALSE"; - // clang-format on - } - return ""; - } - - bool checkIfShouldThrow(assertType::Enum assert_type) { - if(assert_type & assertType::is_require) //!OCLINT bitwise operator in conditional - return true; - - if((assert_type & assertType::is_check) //!OCLINT bitwise operator in conditional - && contextState->abort_after > 0 && - contextState->numFailedAssertions >= contextState->abort_after) - return true; - - return false; - } - void fastAssertThrowIfFlagSet(int flags) { - if(flags & assertAction::shouldthrow) //!OCLINT bitwise operator in conditional - throwException(); - } - void throwException() { -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS - throw TestFailureException(); -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - } - - // matching of a string against a wildcard mask (case sensitivity configurable) taken from - // http://www.emoticode.net/c/simple-wildcard-string-compare-globbing-function.html - int wildcmp(const char* str, const char* wild, bool caseSensitive) { - const char* cp = 0; - const char* mp = 0; - - // rolled my own tolower() to not include more headers - while((*str) && (*wild != '*')) { - if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) && - (*wild != '?')) { - return 0; - } - wild++; - str++; - } - - while(*str) { - if(*wild == '*') { - if(!*++wild) { - return 1; - } - mp = wild; - cp = str + 1; - } else if((caseSensitive ? (*wild == *str) : (tolower(*wild) == tolower(*str))) || - (*wild == '?')) { - wild++; - str++; - } else { - wild = mp; //!OCLINT parameter reassignment - str = cp++; //!OCLINT parameter reassignment - } - } - - while(*wild == '*') { - wild++; - } - return !*wild; - } - - //// C string hash function (djb2) - taken from http://www.cse.yorku.ca/~oz/hash.html - //unsigned hashStr(unsigned const char* str) { - // unsigned long hash = 5381; - // char c; - // while((c = *str++)) - // hash = ((hash << 5) + hash) + c; // hash * 33 + c - // return hash; - //} - - // checks if the name matches any of the filters (and can be configured what to do when empty) - bool matchesAny(const char* name, const std::vector& filters, int matchEmpty, - bool caseSensitive) { - if(filters.empty() && matchEmpty) - return true; - for(unsigned i = 0; i < filters.size(); ++i) - if(wildcmp(name, filters[i].c_str(), caseSensitive)) - return true; - return false; - } - -#ifdef _WIN32 - - typedef unsigned long long UInt64; - - UInt64 getCurrentTicks() { - static UInt64 hz = 0, hzo = 0; - if(!hz) { - QueryPerformanceFrequency(reinterpret_cast(&hz)); - QueryPerformanceCounter(reinterpret_cast(&hzo)); - } - UInt64 t; - QueryPerformanceCounter(reinterpret_cast(&t)); - return ((t - hzo) * 1000000) / hz; - } -#else // _WIN32 - - typedef uint64_t UInt64; - - UInt64 getCurrentTicks() { - timeval t; - gettimeofday(&t, 0); - return static_cast(t.tv_sec) * 1000000 + static_cast(t.tv_usec); - } -#endif // _WIN32 - - class Timer - { - public: - Timer() - : m_ticks(0) {} - void start() { m_ticks = getCurrentTicks(); } - unsigned int getElapsedMicroseconds() const { - return static_cast(getCurrentTicks() - m_ticks); - } - unsigned int getElapsedMilliseconds() const { - return static_cast(getElapsedMicroseconds() / 1000); - } - double getElapsedSeconds() const { return getElapsedMicroseconds() / 1000000.0; } - - private: - UInt64 m_ticks; - }; - - TestAccessibleContextState* getTestsContextState() { return contextState; } - - bool SubcaseSignature::operator<(const SubcaseSignature& other) const { - if(m_line != other.m_line) - return m_line < other.m_line; - if(std::strcmp(m_file, other.m_file) != 0) - return std::strcmp(m_file, other.m_file) < 0; - return std::strcmp(m_name, other.m_name) < 0; - } - - Subcase::Subcase(const char* name, const char* file, int line) - : m_signature(name, file, line) - , m_entered(false) { - ContextState* s = contextState; - - // if we have already completed it - if(s->subcasesPassed.count(m_signature) != 0) - return; - - // check subcase filters - if(s->subcasesCurrentLevel < s->subcase_filter_levels) { - if(!matchesAny(m_signature.m_name, s->filters[6], 1, s->case_sensitive)) - return; - if(matchesAny(m_signature.m_name, s->filters[7], 0, s->case_sensitive)) - return; - } - - // if a Subcase on the same level has already been entered - if(s->subcasesEnteredLevels.count(s->subcasesCurrentLevel) != 0) { - s->subcasesHasSkipped = true; - return; - } - - s->subcasesStack.push_back(*this); - if(s->hasLoggedCurrentTestStart) - logTestEnd(); - s->hasLoggedCurrentTestStart = false; - - s->subcasesEnteredLevels.insert(s->subcasesCurrentLevel++); - m_entered = true; - } - - Subcase::Subcase(const Subcase& other) - : m_signature(other.m_signature.m_name, other.m_signature.m_file, - other.m_signature.m_line) - , m_entered(other.m_entered) {} - - Subcase::~Subcase() { - if(m_entered) { - ContextState* s = contextState; - - s->subcasesCurrentLevel--; - // only mark the subcase as passed if no subcases have been skipped - if(s->subcasesHasSkipped == false) - s->subcasesPassed.insert(m_signature); - - if(!s->subcasesStack.empty()) - s->subcasesStack.pop_back(); - if(s->hasLoggedCurrentTestStart) - logTestEnd(); - s->hasLoggedCurrentTestStart = false; - } - } - - Result::~Result() {} - - Result& Result::operator=(const Result& other) { - m_passed = other.m_passed; - m_decomposition = other.m_decomposition; - - return *this; - } - - // for sorting tests by file/line - int fileOrderComparator(const void* a, const void* b) { - const TestCase* lhs = *static_cast(a); - const TestCase* rhs = *static_cast(b); -#ifdef _MSC_VER - // this is needed because MSVC gives different case for drive letters - // for __FILE__ when evaluated in a header and a source file - int res = stricmp(lhs->m_file, rhs->m_file); -#else // _MSC_VER - int res = std::strcmp(lhs->m_file, rhs->m_file); -#endif // _MSC_VER - if(res != 0) - return res; - return static_cast(lhs->m_line - rhs->m_line); - } - - // for sorting tests by suite/file/line - int suiteOrderComparator(const void* a, const void* b) { - const TestCase* lhs = *static_cast(a); - const TestCase* rhs = *static_cast(b); - - int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite); - if(res != 0) - return res; - return fileOrderComparator(a, b); - } - - // for sorting tests by name/suite/file/line - int nameOrderComparator(const void* a, const void* b) { - const TestCase* lhs = *static_cast(a); - const TestCase* rhs = *static_cast(b); - - int res_name = std::strcmp(lhs->m_name, rhs->m_name); - if(res_name != 0) - return res_name; - return suiteOrderComparator(a, b); - } - - // sets the current test suite - int setTestSuite(const TestSuite& ts) { - doctest_detail_test_suite_ns::getCurrentTestSuite() = ts; - return 0; - } - - // all the registered tests - std::set& getRegisteredTests() { - static std::set data; - return data; - } - - // used by the macros for registering tests - int regTest(const TestCase& tc) { - getRegisteredTests().insert(tc); - return 0; - } - - struct Color - { - enum Code - { - None = 0, - White, - Red, - Green, - Blue, - Cyan, - Yellow, - Grey, - - Bright = 0x10, - - BrightRed = Bright | Red, - BrightGreen = Bright | Green, - LightGrey = Bright | Grey, - BrightWhite = Bright | White - }; - explicit Color(Code code) { use(code); } - ~Color() { use(None); } - - static void use(Code code); - static void init(); - }; - -#ifdef DOCTEST_CONFIG_COLORS_WINDOWS - HANDLE g_stdoutHandle; - WORD g_originalForegroundAttributes; - WORD g_originalBackgroundAttributes; - bool g_attrsInitted = false; -#endif // DOCTEST_CONFIG_COLORS_WINDOWS - - void Color::init() { -#ifdef DOCTEST_CONFIG_COLORS_WINDOWS - if(!g_attrsInitted) { - g_stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE); - g_attrsInitted = true; - CONSOLE_SCREEN_BUFFER_INFO csbiInfo; - GetConsoleScreenBufferInfo(g_stdoutHandle, &csbiInfo); - g_originalForegroundAttributes = - csbiInfo.wAttributes & - ~(BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY); - g_originalBackgroundAttributes = - csbiInfo.wAttributes & - ~(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY); - } -#endif // DOCTEST_CONFIG_COLORS_WINDOWS - } - - void Color::use(Code -#ifndef DOCTEST_CONFIG_COLORS_NONE - code -#endif // DOCTEST_CONFIG_COLORS_NONE - ) { - const ContextState* p = contextState; - if(p->no_colors) - return; -#ifdef DOCTEST_CONFIG_COLORS_ANSI - if(isatty(STDOUT_FILENO) == false && p->force_colors == false) - return; - - const char* col = ""; - // clang-format off - switch(code) { //!OCLINT missing break in switch statement / unnecessary default statement in covered switch statement - case Color::Red: col = "[0;31m"; break; - case Color::Green: col = "[0;32m"; break; - case Color::Blue: col = "[0;34m"; break; - case Color::Cyan: col = "[0;36m"; break; - case Color::Yellow: col = "[0;33m"; break; - case Color::Grey: col = "[1;30m"; break; - case Color::LightGrey: col = "[0;37m"; break; - case Color::BrightRed: col = "[1;31m"; break; - case Color::BrightGreen: col = "[1;32m"; break; - case Color::BrightWhite: col = "[1;37m"; break; - case Color::Bright: // invalid - case Color::None: - case Color::White: - default: col = "[0m"; - } - // clang-format on - std::printf("\033%s", col); -#endif // DOCTEST_CONFIG_COLORS_ANSI - -#ifdef DOCTEST_CONFIG_COLORS_WINDOWS - if(isatty(fileno(stdout)) == false && p->force_colors == false) - return; - -#define DOCTEST_SET_ATTR(x) \ - SetConsoleTextAttribute(g_stdoutHandle, x | g_originalBackgroundAttributes) - - // clang-format off - switch (code) { - case Color::White: DOCTEST_SET_ATTR(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break; - case Color::Red: DOCTEST_SET_ATTR(FOREGROUND_RED); break; - case Color::Green: DOCTEST_SET_ATTR(FOREGROUND_GREEN); break; - case Color::Blue: DOCTEST_SET_ATTR(FOREGROUND_BLUE); break; - case Color::Cyan: DOCTEST_SET_ATTR(FOREGROUND_BLUE | FOREGROUND_GREEN); break; - case Color::Yellow: DOCTEST_SET_ATTR(FOREGROUND_RED | FOREGROUND_GREEN); break; - case Color::Grey: DOCTEST_SET_ATTR(0); break; - case Color::LightGrey: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY); break; - case Color::BrightRed: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_RED); break; - case Color::BrightGreen: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN); break; - case Color::BrightWhite: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break; - case Color::None: - case Color::Bright: // invalid - default: DOCTEST_SET_ATTR(g_originalForegroundAttributes); - } -// clang-format on -#undef DOCTEST_SET_ATTR -#endif // DOCTEST_CONFIG_COLORS_WINDOWS - } - - IExceptionTranslator::~IExceptionTranslator() {} - - std::vector& getExceptionTranslators() { - static std::vector data; - return data; - } - - void registerExceptionTranslatorImpl(const IExceptionTranslator* translateFunction) { - getExceptionTranslators().push_back(translateFunction); - } - - String translateActiveException() { -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS - String res; - std::vector& translators = getExceptionTranslators(); - for(size_t i = 0; i < translators.size(); ++i) - if(translators[i]->translate(res)) - return res; - // clang-format off - try { - throw; - } catch(std::exception& ex) { - return ex.what(); - } catch(std::string& msg) { - return msg.c_str(); - } catch(const char* msg) { - return msg; - } catch(...) { - return "unknown exception"; - } -// clang-format on -#else // DOCTEST_CONFIG_NO_EXCEPTIONS - return ""; -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - } - - void writeStringToStream(std::ostream* stream, const String& str) { *stream << str; } - -#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING - void toStream(std::ostream* stream, char* in) { *stream << in; } - void toStream(std::ostream* stream, const char* in) { *stream << in; } -#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING - void toStream(std::ostream* stream, bool in) { - *stream << std::boolalpha << in << std::noboolalpha; - } - void toStream(std::ostream* stream, float in) { *stream << in; } - void toStream(std::ostream* stream, double in) { *stream << in; } - void toStream(std::ostream* stream, double long in) { *stream << in; } - - void toStream(std::ostream* stream, char in) { *stream << in; } - void toStream(std::ostream* stream, char signed in) { *stream << in; } - void toStream(std::ostream* stream, char unsigned in) { *stream << in; } - void toStream(std::ostream* stream, int short in) { *stream << in; } - void toStream(std::ostream* stream, int short unsigned in) { *stream << in; } - void toStream(std::ostream* stream, int in) { *stream << in; } - void toStream(std::ostream* stream, int unsigned in) { *stream << in; } - void toStream(std::ostream* stream, int long in) { *stream << in; } - void toStream(std::ostream* stream, int long unsigned in) { *stream << in; } - -#ifdef DOCTEST_CONFIG_WITH_LONG_LONG - void toStream(std::ostream* stream, int long long in) { *stream << in; } - void toStream(std::ostream* stream, int long long unsigned in) { *stream << in; } -#endif // DOCTEST_CONFIG_WITH_LONG_LONG - - void addToContexts(IContextScope* ptr) { contextState->contexts.push_back(ptr); } - void popFromContexts() { contextState->contexts.pop_back(); } - void useContextIfExceptionOccurred(IContextScope* ptr) { - if(std::uncaught_exception()) { - std::ostringstream stream; - ptr->build(&stream); - contextState->exceptionalContexts.push_back(stream.str()); - } - } - - void printSummary(); - -#if !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && !defined(DOCTEST_CONFIG_WINDOWS_SEH) - void reportFatal(const std::string&) {} - struct FatalConditionHandler - { - void reset() {} - }; -#else // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH - - void reportFatal(const std::string& message) { - DOCTEST_LOG_START(); - - contextState->numAssertions += contextState->numAssertionsForCurrentTestcase; - logTestException(message.c_str(), true); - logTestEnd(); - contextState->numFailed++; - - printSummary(); - } - -#ifdef DOCTEST_PLATFORM_WINDOWS - - struct SignalDefs - { - DWORD id; - const char* name; - }; - // There is no 1-1 mapping between signals and windows exceptions. - // Windows can easily distinguish between SO and SigSegV, - // but SigInt, SigTerm, etc are handled differently. - SignalDefs signalDefs[] = { - {EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal"}, - {EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow"}, - {EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal"}, - {EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error"}, - }; - - struct FatalConditionHandler - { - static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) { - for(size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { - if(ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) { - reportFatal(signalDefs[i].name); - } - } - // If its not an exception we care about, pass it along. - // This stops us from eating debugger breaks etc. - return EXCEPTION_CONTINUE_SEARCH; - } - - FatalConditionHandler() { - isSet = true; - // 32k seems enough for doctest to handle stack overflow, - // but the value was found experimentally, so there is no strong guarantee - guaranteeSize = 32 * 1024; - exceptionHandlerHandle = 0; - // Register as first handler in current chain - exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException); - // Pass in guarantee size to be filled - SetThreadStackGuarantee(&guaranteeSize); - } - - static void reset() { - if(isSet) { - // Unregister handler and restore the old guarantee - RemoveVectoredExceptionHandler(exceptionHandlerHandle); - SetThreadStackGuarantee(&guaranteeSize); - exceptionHandlerHandle = 0; - isSet = false; - } - } - - ~FatalConditionHandler() { reset(); } - - private: - static bool isSet; - static ULONG guaranteeSize; - static PVOID exceptionHandlerHandle; - }; - - bool FatalConditionHandler::isSet = false; - ULONG FatalConditionHandler::guaranteeSize = 0; - PVOID FatalConditionHandler::exceptionHandlerHandle = 0; - -#else // DOCTEST_PLATFORM_WINDOWS - - struct SignalDefs - { - int id; - const char* name; - }; - SignalDefs signalDefs[] = {{SIGINT, "SIGINT - Terminal interrupt signal"}, - {SIGILL, "SIGILL - Illegal instruction signal"}, - {SIGFPE, "SIGFPE - Floating point error signal"}, - {SIGSEGV, "SIGSEGV - Segmentation violation signal"}, - {SIGTERM, "SIGTERM - Termination request signal"}, - {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}}; - - struct FatalConditionHandler - { - static bool isSet; - static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]; - static stack_t oldSigStack; - static char altStackMem[SIGSTKSZ]; - - static void handleSignal(int sig) { - std::string name = ""; - for(std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { - SignalDefs& def = signalDefs[i]; - if(sig == def.id) { - name = def.name; - break; - } - } - reset(); - reportFatal(name); - raise(sig); - } - - FatalConditionHandler() { - isSet = true; - stack_t sigStack; - sigStack.ss_sp = altStackMem; - sigStack.ss_size = SIGSTKSZ; - sigStack.ss_flags = 0; - sigaltstack(&sigStack, &oldSigStack); - struct sigaction sa = {0}; - - sa.sa_handler = handleSignal; // NOLINT - sa.sa_flags = SA_ONSTACK; - for(std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { - sigaction(signalDefs[i].id, &sa, &oldSigActions[i]); - } - } - - ~FatalConditionHandler() { reset(); } - static void reset() { - if(isSet) { - // Set signals back to previous values -- hopefully nobody overwrote them in the meantime - for(std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { - sigaction(signalDefs[i].id, &oldSigActions[i], 0); - } - // Return the old stack - sigaltstack(&oldSigStack, 0); - isSet = false; - } - } - }; - - bool FatalConditionHandler::isSet = false; - struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)] = - {}; - stack_t FatalConditionHandler::oldSigStack = {}; - char FatalConditionHandler::altStackMem[SIGSTKSZ] = {}; - -#endif // DOCTEST_PLATFORM_WINDOWS -#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH - - // depending on the current options this will remove the path of filenames - const char* fileForOutput(const char* file) { - if(contextState->no_path_in_filenames) { - const char* back = std::strrchr(file, '\\'); - const char* forward = std::strrchr(file, '/'); - if(back || forward) { - if(back > forward) - forward = back; - return forward + 1; - } - } - return file; - } - - // depending on the current options this will substitute the line numbers with 0 - int lineForOutput(int line) { - if(contextState->no_line_numbers) - return 0; - return line; - } - -#ifdef DOCTEST_PLATFORM_MAC -#include -#include -#include - // The following function is taken directly from the following technical note: - // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html - // Returns true if the current process is being debugged (either - // running under the debugger or has a debugger attached post facto). - bool isDebuggerActive() { - int mib[4]; - kinfo_proc info; - size_t size; - // Initialize the flags so that, if sysctl fails for some bizarre - // reason, we get a predictable result. - info.kp_proc.p_flag = 0; - // Initialize mib, which tells sysctl the info we want, in this case - // we're looking for information about a specific process ID. - mib[0] = CTL_KERN; - mib[1] = KERN_PROC; - mib[2] = KERN_PROC_PID; - mib[3] = getpid(); - // Call sysctl. - size = sizeof(info); - if(sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, 0, 0) != 0) { - fprintf(stderr, "\n** Call to sysctl failed - unable to determine if debugger is " - "active **\n\n"); - return false; - } - // We're being debugged if the P_TRACED flag is set. - return ((info.kp_proc.p_flag & P_TRACED) != 0); - } -#elif defined(_MSC_VER) || defined(__MINGW32__) - bool isDebuggerActive() { return ::IsDebuggerPresent() != 0; } -#else - bool isDebuggerActive() { return false; } -#endif // Platform - -#ifdef DOCTEST_PLATFORM_WINDOWS - void myOutputDebugString(const String& text) { ::OutputDebugStringA(text.c_str()); } -#else - // TODO: integration with XCode and other IDEs - void myOutputDebugString(const String&) {} -#endif // Platform - - const char* getSeparator() { - return "===============================================================================\n"; - } - - void printToDebugConsole(const String& text) { - if(isDebuggerActive()) - myOutputDebugString(text.c_str()); - } - - void addFailedAssert(assertType::Enum assert_type) { - if((assert_type & assertType::is_warn) == 0) { //!OCLINT bitwise operator in conditional - contextState->numFailedAssertions++; - contextState->numFailedAssertionsForCurrentTestcase++; - contextState->hasCurrentTestFailed = true; - } - } - - void logTestStart(const TestCase& tc) { - char loc[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(loc, DOCTEST_COUNTOF(loc), "%s(%d)\n", fileForOutput(tc.m_file), - lineForOutput(tc.m_line)); - - char ts1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(ts1, DOCTEST_COUNTOF(ts1), "TEST SUITE: "); - char ts2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(ts2, DOCTEST_COUNTOF(ts2), "%s\n", tc.m_test_suite); - char n1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(n1, DOCTEST_COUNTOF(n1), "TEST CASE: "); - char n2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(n2, DOCTEST_COUNTOF(n2), "%s\n", tc.m_name); - char d1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(d1, DOCTEST_COUNTOF(d1), "DESCRIPTION: "); - char d2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(d2, DOCTEST_COUNTOF(d2), "%s\n", tc.m_description); - - // hack for BDD style of macros - to not print "TEST CASE:" - char scenario[] = " Scenario:"; - if(std::string(tc.m_name).substr(0, DOCTEST_COUNTOF(scenario) - 1) == scenario) - n1[0] = '\0'; - - DOCTEST_PRINTF_COLORED(getSeparator(), Color::Yellow); - DOCTEST_PRINTF_COLORED(loc, Color::LightGrey); - - String forDebugConsole; - if(tc.m_description) { - DOCTEST_PRINTF_COLORED(d1, Color::Yellow); - DOCTEST_PRINTF_COLORED(d2, Color::None); - forDebugConsole += d1; - forDebugConsole += d2; - } - if(tc.m_test_suite[0] != '\0') { - DOCTEST_PRINTF_COLORED(ts1, Color::Yellow); - DOCTEST_PRINTF_COLORED(ts2, Color::None); - forDebugConsole += ts1; - forDebugConsole += ts2; - } - DOCTEST_PRINTF_COLORED(n1, Color::Yellow); - DOCTEST_PRINTF_COLORED(n2, Color::None); - - String subcaseStuff; - std::vector& subcasesStack = contextState->subcasesStack; - for(unsigned i = 0; i < subcasesStack.size(); ++i) { - if(subcasesStack[i].m_signature.m_name[0] != '\0') { - char subcase[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(subcase, DOCTEST_COUNTOF(loc), " %s\n", - subcasesStack[i].m_signature.m_name); - DOCTEST_PRINTF_COLORED(subcase, Color::None); - subcaseStuff += subcase; - } - } - - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(getSeparator()) + loc + forDebugConsole.c_str() + n1 + n2 + - subcaseStuff.c_str() + "\n"); - } - - void logTestEnd() {} - - void logTestException(const String& what, bool crash) { - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), "TEST CASE FAILED!\n"); - - char info1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - char info2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - info1[0] = 0; - info2[0] = 0; - DOCTEST_SNPRINTF(info1, DOCTEST_COUNTOF(info1), - crash ? "crashed:\n" : "threw exception:\n"); - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), " %s\n", what.c_str()); - - std::string contextStr; - - if(!contextState->exceptionalContexts.empty()) { - contextStr += "with context:\n"; - for(size_t i = contextState->exceptionalContexts.size(); i > 0; --i) { - contextStr += " "; - contextStr += contextState->exceptionalContexts[i - 1]; - contextStr += "\n"; - } - } - - DOCTEST_PRINTF_COLORED(msg, Color::Red); - DOCTEST_PRINTF_COLORED(info1, Color::None); - DOCTEST_PRINTF_COLORED(info2, Color::Cyan); - DOCTEST_PRINTF_COLORED(contextStr.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(msg) + info1 + info2 + contextStr.c_str() + "\n"); - } - - String logContext() { - std::ostringstream stream; - std::vector& contexts = contextState->contexts; - if(!contexts.empty()) - stream << "with context:\n"; - for(size_t i = 0; i < contexts.size(); ++i) { - stream << " "; - contexts[i]->build(&stream); - stream << "\n"; - } - return stream.str().c_str(); - } - - const char* getFailString(assertType::Enum assert_type) { - if(assert_type & assertType::is_warn) //!OCLINT bitwise operator in conditional - return "WARNING"; - if(assert_type & assertType::is_check) //!OCLINT bitwise operator in conditional - return "ERROR"; - if(assert_type & assertType::is_require) //!OCLINT bitwise operator in conditional - return "FATAL ERROR"; - return ""; - } - - void logAssert(bool passed, const char* decomposition, bool threw, const String& exception, - const char* expr, assertType::Enum assert_type, const char* file, int line) { - char loc[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(loc, DOCTEST_COUNTOF(loc), "%s(%d)", fileForOutput(file), - lineForOutput(line)); - - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), " %s!\n", - passed ? "PASSED" : getFailString(assert_type)); - - char info1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(info1, DOCTEST_COUNTOF(info1), " %s( %s )\n", - getAssertString(assert_type), expr); - - char info2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - char info3[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - info2[0] = 0; - info3[0] = 0; - if(threw) { - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), "threw exception:\n"); - DOCTEST_SNPRINTF(info3, DOCTEST_COUNTOF(info3), " %s\n", exception.c_str()); - } else { - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), "with expansion:\n"); - DOCTEST_SNPRINTF(info3, DOCTEST_COUNTOF(info3), " %s( %s )\n", - getAssertString(assert_type), decomposition); - } - - bool isWarn = assert_type & assertType::is_warn; - DOCTEST_PRINTF_COLORED(loc, Color::LightGrey); - DOCTEST_PRINTF_COLORED(msg, - passed ? Color::BrightGreen : isWarn ? Color::Yellow : Color::Red); - DOCTEST_PRINTF_COLORED(info1, Color::Cyan); - DOCTEST_PRINTF_COLORED(info2, Color::None); - DOCTEST_PRINTF_COLORED(info3, Color::Cyan); - String context = logContext(); - DOCTEST_PRINTF_COLORED(context.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(loc) + msg + info1 + info2 + info3 + context.c_str() + "\n"); - } - - void logAssertThrows(bool threw, const char* expr, assertType::Enum assert_type, - const char* file, int line) { - char loc[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(loc, DOCTEST_COUNTOF(loc), "%s(%d)", fileForOutput(file), - lineForOutput(line)); - - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), " %s!\n", - threw ? "PASSED" : getFailString(assert_type)); - - char info1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(info1, DOCTEST_COUNTOF(info1), " %s( %s )\n", - getAssertString(assert_type), expr); - - char info2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - info2[0] = 0; - - if(!threw) - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), "didn't throw at all\n"); - - bool isWarn = assert_type & assertType::is_warn; - DOCTEST_PRINTF_COLORED(loc, Color::LightGrey); - DOCTEST_PRINTF_COLORED(msg, - threw ? Color::BrightGreen : isWarn ? Color::Yellow : Color::Red); - DOCTEST_PRINTF_COLORED(info1, Color::Cyan); - DOCTEST_PRINTF_COLORED(info2, Color::None); - String context = logContext(); - DOCTEST_PRINTF_COLORED(context.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(loc) + msg + info1 + info2 + context.c_str() + "\n"); - } - - void logAssertThrowsAs(bool threw, bool threw_as, const char* as, const String& exception, - const char* expr, assertType::Enum assert_type, const char* file, - int line) { - char loc[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(loc, DOCTEST_COUNTOF(loc), "%s(%d)", fileForOutput(file), - lineForOutput(line)); - - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), " %s!\n", - threw_as ? "PASSED" : getFailString(assert_type)); - - char info1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(info1, DOCTEST_COUNTOF(info1), " %s( %s, %s )\n", - getAssertString(assert_type), expr, as); - - char info2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - char info3[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - info2[0] = 0; - info3[0] = 0; - - if(!threw) { //!OCLINT inverted logic - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), "didn't throw at all\n"); - } else if(!threw_as) { - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), "threw a different exception:\n"); - DOCTEST_SNPRINTF(info3, DOCTEST_COUNTOF(info3), " %s\n", exception.c_str()); - } - - bool isWarn = assert_type & assertType::is_warn; - DOCTEST_PRINTF_COLORED(loc, Color::LightGrey); - DOCTEST_PRINTF_COLORED(msg, - threw_as ? Color::BrightGreen : isWarn ? Color::Yellow : Color::Red); - DOCTEST_PRINTF_COLORED(info1, Color::Cyan); - DOCTEST_PRINTF_COLORED(info2, Color::None); - DOCTEST_PRINTF_COLORED(info3, Color::Cyan); - String context = logContext(); - DOCTEST_PRINTF_COLORED(context.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(loc) + msg + info1 + info2 + info3 + context.c_str() + "\n"); - } - - void logAssertNothrow(bool threw, const String& exception, const char* expr, - assertType::Enum assert_type, const char* file, int line) { - char loc[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(loc, DOCTEST_COUNTOF(loc), "%s(%d)", fileForOutput(file), - lineForOutput(line)); - - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), " %s!\n", - threw ? getFailString(assert_type) : "PASSED"); - - char info1[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(info1, DOCTEST_COUNTOF(info1), " %s( %s )\n", - getAssertString(assert_type), expr); - - char info2[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - char info3[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - info2[0] = 0; - info3[0] = 0; - if(threw) { - DOCTEST_SNPRINTF(info2, DOCTEST_COUNTOF(info2), "threw exception:\n"); - DOCTEST_SNPRINTF(info3, DOCTEST_COUNTOF(info3), " %s\n", exception.c_str()); - } - - bool isWarn = assert_type & assertType::is_warn; - DOCTEST_PRINTF_COLORED(loc, Color::LightGrey); - DOCTEST_PRINTF_COLORED(msg, - threw ? isWarn ? Color::Yellow : Color::Red : Color::BrightGreen); - DOCTEST_PRINTF_COLORED(info1, Color::Cyan); - DOCTEST_PRINTF_COLORED(info2, Color::None); - DOCTEST_PRINTF_COLORED(info3, Color::Cyan); - String context = logContext(); - DOCTEST_PRINTF_COLORED(context.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(loc) + msg + info1 + info2 + info3 + context.c_str() + "\n"); - } - - ResultBuilder::ResultBuilder(assertType::Enum assert_type, const char* file, int line, - const char* expr, const char* exception_type) - : m_assert_type(assert_type) - , m_file(file) - , m_line(line) - , m_expr(expr) - , m_exception_type(exception_type) - , m_threw(false) - , m_threw_as(false) - , m_failed(false) { -#ifdef _MSC_VER - if(m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC - ++m_expr; -#endif // _MSC_VER - } - - ResultBuilder::~ResultBuilder() {} - - void ResultBuilder::unexpectedExceptionOccurred() { - m_threw = true; - - m_exception = translateActiveException(); - } - - bool ResultBuilder::log() { - if((m_assert_type & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional - contextState->numAssertionsForCurrentTestcase++; - - if(m_assert_type & assertType::is_throws) { //!OCLINT bitwise operator in conditional - m_failed = !m_threw; - } else if(m_assert_type & //!OCLINT bitwise operator in conditional - assertType::is_throws_as) { - m_failed = !m_threw_as; - } else if(m_assert_type & //!OCLINT bitwise operator in conditional - assertType::is_nothrow) { - m_failed = m_threw; - } else { - m_failed = m_result; - } - - if(m_failed || contextState->success) { - DOCTEST_LOG_START(); - - if(m_assert_type & assertType::is_throws) { //!OCLINT bitwise operator in conditional - logAssertThrows(m_threw, m_expr, m_assert_type, m_file, m_line); - } else if(m_assert_type & //!OCLINT bitwise operator in conditional - assertType::is_throws_as) { - logAssertThrowsAs(m_threw, m_threw_as, m_exception_type, m_exception, m_expr, - m_assert_type, m_file, m_line); - } else if(m_assert_type & //!OCLINT bitwise operator in conditional - assertType::is_nothrow) { - logAssertNothrow(m_threw, m_exception, m_expr, m_assert_type, m_file, m_line); - } else { - logAssert(m_result.m_passed, m_result.m_decomposition.c_str(), m_threw, m_exception, - m_expr, m_assert_type, m_file, m_line); - } - } - - if(m_failed) - addFailedAssert(m_assert_type); - - return m_failed && isDebuggerActive() && !contextState->no_breaks; // break into debugger - } - - void ResultBuilder::react() const { - if(m_failed && checkIfShouldThrow(m_assert_type)) - throwException(); - } - - MessageBuilder::MessageBuilder(const char* file, int line, - doctest::detail::assertType::Enum severity) - : m_stream(createStream()) - , m_file(file) - , m_line(line) - , m_severity(severity) {} - - bool MessageBuilder::log() { - DOCTEST_LOG_START(); - - bool is_warn = m_severity & doctest::detail::assertType::is_warn; - - // warn is just a message in this context so we dont treat it as an assert - if(!is_warn) { - contextState->numAssertionsForCurrentTestcase++; - addFailedAssert(m_severity); - } - - char loc[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(loc, DOCTEST_COUNTOF(loc), "%s(%d)", fileForOutput(m_file), - lineForOutput(m_line)); - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), " %s!\n", - is_warn ? "MESSAGE" : getFailString(m_severity)); - - DOCTEST_PRINTF_COLORED(loc, Color::LightGrey); - DOCTEST_PRINTF_COLORED(msg, is_warn ? Color::Yellow : Color::Red); - - String info = getStreamResult(m_stream); - if(info.size()) { - DOCTEST_PRINTF_COLORED(" ", Color::None); - DOCTEST_PRINTF_COLORED(info.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - } - String context = logContext(); - DOCTEST_PRINTF_COLORED(context.c_str(), Color::None); - DOCTEST_PRINTF_COLORED("\n", Color::None); - - printToDebugConsole(String(loc) + msg + " " + info.c_str() + "\n" + context.c_str() + - "\n"); - - return isDebuggerActive() && !contextState->no_breaks && !is_warn; // break into debugger - } - - void MessageBuilder::react() { - if(m_severity & assertType::is_require) //!OCLINT bitwise operator in conditional - throwException(); - } - - MessageBuilder::~MessageBuilder() { freeStream(m_stream); } - - // the implementation of parseFlag() - bool parseFlagImpl(int argc, const char* const* argv, const char* pattern) { - for(int i = argc - 1; i >= 0; --i) { - const char* temp = std::strstr(argv[i], pattern); - if(temp && my_strlen(temp) == my_strlen(pattern)) { - // eliminate strings in which the chars before the option are not '-' - bool noBadCharsFound = true; //!OCLINT prefer early exits and continue - while(temp != argv[i]) { - if(*--temp != '-') { - noBadCharsFound = false; - break; - } - } - if(noBadCharsFound && argv[i][0] == '-') - return true; - } - } - return false; - } - - // locates a flag on the command line - bool parseFlag(int argc, const char* const* argv, const char* pattern) { -#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS - if(!parseFlagImpl(argc, argv, pattern)) - return parseFlagImpl(argc, argv, pattern + 3); // 3 for "dt-" - return true; -#else // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS - return parseFlagImpl(argc, argv, pattern); -#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS - } - - // the implementation of parseOption() - bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String& res) { - for(int i = argc - 1; i >= 0; --i) { - const char* temp = std::strstr(argv[i], pattern); - if(temp) { //!OCLINT prefer early exits and continue - // eliminate matches in which the chars before the option are not '-' - bool noBadCharsFound = true; - const char* curr = argv[i]; - while(curr != temp) { - if(*curr++ != '-') { - noBadCharsFound = false; - break; - } - } - if(noBadCharsFound && argv[i][0] == '-') { - temp += my_strlen(pattern); - unsigned len = my_strlen(temp); - if(len) { - res = temp; - return true; - } - } - } - } - return false; - } - - // parses an option and returns the string after the '=' character - bool parseOption(int argc, const char* const* argv, const char* pattern, String& res, - const String& defaultVal = String()) { - res = defaultVal; -#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS - if(!parseOptionImpl(argc, argv, pattern, res)) - return parseOptionImpl(argc, argv, pattern + 3, res); // 3 for "dt-" - return true; -#else // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS - return parseOptionImpl(argc, argv, pattern, res); -#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS - } - - // parses a comma separated list of words after a pattern in one of the arguments in argv - bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern, - std::vector& res) { - String filtersString; - if(parseOption(argc, argv, pattern, filtersString)) { - // tokenize with "," as a separator - // cppcheck-suppress strtokCalled - char* pch = std::strtok(filtersString.c_str(), ","); // modifies the string - while(pch != 0) { - if(my_strlen(pch)) - res.push_back(pch); - // uses the strtok() internal state to go to the next token - // cppcheck-suppress strtokCalled - pch = std::strtok(0, ","); - } - return true; - } - return false; - } - - enum optionType - { - option_bool, - option_int - }; - - // parses an int/bool option from the command line - bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type, - int& res) { - String parsedValue; - if(!parseOption(argc, argv, pattern, parsedValue)) - return false; - - if(type == 0) { - // boolean - const char positive[][5] = {"1", "true", "on", "yes"}; // 5 - strlen("true") + 1 - const char negative[][6] = {"0", "false", "off", "no"}; // 6 - strlen("false") + 1 - - // if the value matches any of the positive/negative possibilities - for(unsigned i = 0; i < 4; i++) { - if(parsedValue.compare(positive[i], true) == 0) { - res = 1; //!OCLINT parameter reassignment - return true; - } - if(parsedValue.compare(negative[i], true) == 0) { - res = 0; //!OCLINT parameter reassignment - return true; - } - } - } else { - // integer - int theInt = std::atoi(parsedValue.c_str()); // NOLINT - if(theInt != 0) { - res = theInt; //!OCLINT parameter reassignment - return true; - } - } - return false; - } - - void printVersion() { - if(contextState->no_version == false) { - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("doctest version is \"%s\"\n", DOCTEST_VERSION_STR); - } - } - - void printHelp() { - printVersion(); - // clang-format off - DOCTEST_PRINTF_COLORED("[doctest]\n", Color::Cyan); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("boolean values: \"1/on/yes/true\" or \"0/off/no/false\"\n"); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("filter values: \"str1,str2,str3\" (comma separated strings)\n"); - DOCTEST_PRINTF_COLORED("[doctest]\n", Color::Cyan); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("filters use wildcards for matching strings\n"); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("something passes a filter if any of the strings in a filter matches\n"); - DOCTEST_PRINTF_COLORED("[doctest]\n", Color::Cyan); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A \"dt-\" PREFIX!!!\n"); - DOCTEST_PRINTF_COLORED("[doctest]\n", Color::Cyan); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("Query flags - the program quits after them. Available:\n\n"); - std::printf(" -?, --help, -h prints this message\n"); - std::printf(" -v, --version prints the version\n"); - std::printf(" -c, --count prints the number of matching tests\n"); - std::printf(" -ltc, --list-test-cases lists all matching tests by name\n"); - std::printf(" -lts, --list-test-suites lists all matching test suites\n\n"); - // ========================================================================================= << 79 - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("The available / options/filters are:\n\n"); - std::printf(" -tc, --test-case= filters tests by their name\n"); - std::printf(" -tce, --test-case-exclude= filters OUT tests by their name\n"); - std::printf(" -sf, --source-file= filters tests by their file\n"); - std::printf(" -sfe, --source-file-exclude= filters OUT tests by their file\n"); - std::printf(" -ts, --test-suite= filters tests by their test suite\n"); - std::printf(" -tse, --test-suite-exclude= filters OUT tests by their test suite\n"); - std::printf(" -sc, --subcase= filters subcases by their name\n"); - std::printf(" -sce, --subcase-exclude= filters OUT subcases by their name\n"); - std::printf(" -ob, --order-by= how the tests should be ordered\n"); - std::printf(" - by [file/suite/name/rand]\n"); - std::printf(" -rs, --rand-seed= seed for random ordering\n"); - std::printf(" -f, --first= the first test passing the filters to\n"); - std::printf(" execute - for range-based execution\n"); - std::printf(" -l, --last= the last test passing the filters to\n"); - std::printf(" execute - for range-based execution\n"); - std::printf(" -aa, --abort-after= stop after failed assertions\n"); - std::printf(" -scfl,--subcase-filter-levels= apply filters for the first levels\n"); - DOCTEST_PRINTF_COLORED("\n[doctest] ", Color::Cyan); - std::printf("Bool options - can be used like flags and true is assumed. Available:\n\n"); - std::printf(" -s, --success= include successful assertions in output\n"); - std::printf(" -cs, --case-sensitive= filters being treated as case sensitive\n"); - std::printf(" -e, --exit= exits after the tests finish\n"); - std::printf(" -d, --duration= prints the time duration of each test\n"); - std::printf(" -nt, --no-throw= skips exceptions-related assert checks\n"); - std::printf(" -ne, --no-exitcode= returns (or exits) always with success\n"); - std::printf(" -nr, --no-run= skips all runtime doctest operations\n"); - std::printf(" -nv, --no-version= omit the framework version in the output\n"); - std::printf(" -nc, --no-colors= disables colors in output\n"); - std::printf(" -fc, --force-colors= use colors even when not in a tty\n"); - std::printf(" -nb, --no-breaks= disables breakpoints in debuggers\n"); - std::printf(" -ns, --no-skip= don't skip test cases marked as skip\n"); - std::printf(" -npf, --no-path-filenames= only filenames and no paths in output\n"); - std::printf(" -nln, --no-line-numbers= 0 instead of real line numbers in output\n"); - // ========================================================================================= << 79 - // clang-format on - - DOCTEST_PRINTF_COLORED("\n[doctest] ", Color::Cyan); - std::printf("for more information visit the project documentation\n\n"); - } - - void printSummary() { - const ContextState* p = contextState; - - DOCTEST_PRINTF_COLORED(getSeparator(), Color::Yellow); - if(p->count || p->list_test_cases) { - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("unskipped test cases passing the current filters: %u\n", - p->numTestsPassingFilters); - } else if(p->list_test_suites) { - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("unskipped test cases passing the current filters: %u\n", - p->numTestsPassingFilters); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("test suites with unskipped test cases passing the current filters: %u\n", - p->numTestSuitesPassingFilters); - } else { - bool anythingFailed = p->numFailed > 0 || p->numFailedAssertions > 0; - - char buff[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "test cases: %6u", - p->numTestsPassingFilters); - DOCTEST_PRINTF_COLORED(buff, Color::None); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), " | "); - DOCTEST_PRINTF_COLORED(buff, Color::None); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "%6d passed", - p->numTestsPassingFilters - p->numFailed); - DOCTEST_PRINTF_COLORED(buff, - (p->numTestsPassingFilters == 0 || anythingFailed) ? - Color::None : - Color::Green); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), " | "); - DOCTEST_PRINTF_COLORED(buff, Color::None); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "%6u failed", p->numFailed); - DOCTEST_PRINTF_COLORED(buff, p->numFailed > 0 ? Color::Red : Color::None); - - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), " | "); - DOCTEST_PRINTF_COLORED(buff, Color::None); - if(p->no_skipped_summary == false) { - int numSkipped = static_cast(getRegisteredTests().size()) - - p->numTestsPassingFilters; - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "%6d skipped", numSkipped); - DOCTEST_PRINTF_COLORED(buff, numSkipped == 0 ? Color::None : Color::Yellow); - } - DOCTEST_PRINTF_COLORED("\n", Color::None); - - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "assertions: %6d", p->numAssertions); - DOCTEST_PRINTF_COLORED(buff, Color::None); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), " | "); - DOCTEST_PRINTF_COLORED(buff, Color::None); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "%6d passed", - p->numAssertions - p->numFailedAssertions); - DOCTEST_PRINTF_COLORED( - buff, (p->numAssertions == 0 || anythingFailed) ? Color::None : Color::Green); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), " | "); - DOCTEST_PRINTF_COLORED(buff, Color::None); - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), "%6d failed", p->numFailedAssertions); - DOCTEST_PRINTF_COLORED(buff, p->numFailedAssertions > 0 ? Color::Red : Color::None); - - DOCTEST_SNPRINTF(buff, DOCTEST_COUNTOF(buff), " |\n"); - DOCTEST_PRINTF_COLORED(buff, Color::None); - - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - DOCTEST_PRINTF_COLORED("Status: ", Color::None); - const char* result = (p->numFailed > 0) ? "FAILURE!\n" : "SUCCESS!\n"; - DOCTEST_PRINTF_COLORED(result, p->numFailed > 0 ? Color::Red : Color::Green); - } - - // remove any coloring - DOCTEST_PRINTF_COLORED("", Color::None); - } -} // namespace detail - -bool isRunningInTest() { return detail::contextState != 0; } - -Context::Context(int argc, const char* const* argv) - : p(new detail::ContextState) { - parseArgs(argc, argv, true); -} - -Context::~Context() { delete p; } - -void Context::applyCommandLine(int argc, const char* const* argv) { parseArgs(argc, argv); } - -// parses args -void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) { - using namespace detail; - - // clang-format off - parseCommaSepArgs(argc, argv, "dt-source-file=", p->filters[0]); - parseCommaSepArgs(argc, argv, "dt-sf=", p->filters[0]); - parseCommaSepArgs(argc, argv, "dt-source-file-exclude=",p->filters[1]); - parseCommaSepArgs(argc, argv, "dt-sfe=", p->filters[1]); - parseCommaSepArgs(argc, argv, "dt-test-suite=", p->filters[2]); - parseCommaSepArgs(argc, argv, "dt-ts=", p->filters[2]); - parseCommaSepArgs(argc, argv, "dt-test-suite-exclude=", p->filters[3]); - parseCommaSepArgs(argc, argv, "dt-tse=", p->filters[3]); - parseCommaSepArgs(argc, argv, "dt-test-case=", p->filters[4]); - parseCommaSepArgs(argc, argv, "dt-tc=", p->filters[4]); - parseCommaSepArgs(argc, argv, "dt-test-case-exclude=", p->filters[5]); - parseCommaSepArgs(argc, argv, "dt-tce=", p->filters[5]); - parseCommaSepArgs(argc, argv, "dt-subcase=", p->filters[6]); - parseCommaSepArgs(argc, argv, "dt-sc=", p->filters[6]); - parseCommaSepArgs(argc, argv, "dt-subcase-exclude=", p->filters[7]); - parseCommaSepArgs(argc, argv, "dt-sce=", p->filters[7]); - // clang-format on - - int intRes = 0; - String strRes; - -#define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default) \ - if(parseIntOption(argc, argv, DOCTEST_STR_CONCAT_TOSTR(name, =), option_bool, intRes) || \ - parseIntOption(argc, argv, DOCTEST_STR_CONCAT_TOSTR(sname, =), option_bool, intRes)) \ - p->var = !!intRes; \ - else if(parseFlag(argc, argv, #name) || parseFlag(argc, argv, #sname)) \ - p->var = true; \ - else if(withDefaults) \ - p->var = default - -#define DOCTEST_PARSE_INT_OPTION(name, sname, var, default) \ - if(parseIntOption(argc, argv, DOCTEST_STR_CONCAT_TOSTR(name, =), option_int, intRes) || \ - parseIntOption(argc, argv, DOCTEST_STR_CONCAT_TOSTR(sname, =), option_int, intRes)) \ - p->var = intRes; \ - else if(withDefaults) \ - p->var = default - -#define DOCTEST_PARSE_STR_OPTION(name, sname, var, default) \ - if(parseOption(argc, argv, DOCTEST_STR_CONCAT_TOSTR(name, =), strRes, default) || \ - parseOption(argc, argv, DOCTEST_STR_CONCAT_TOSTR(sname, =), strRes, default) || \ - withDefaults) \ - p->var = strRes - - // clang-format off - DOCTEST_PARSE_STR_OPTION(dt-order-by, dt-ob, order_by, "file"); - DOCTEST_PARSE_INT_OPTION(dt-rand-seed, dt-rs, rand_seed, 0); - - DOCTEST_PARSE_INT_OPTION(dt-first, dt-f, first, 1); - DOCTEST_PARSE_INT_OPTION(dt-last, dt-l, last, 0); - - DOCTEST_PARSE_INT_OPTION(dt-abort-after, dt-aa, abort_after, 0); - DOCTEST_PARSE_INT_OPTION(dt-subcase-filter-levels, dt-scfl, subcase_filter_levels, 2000000000); - - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-success, dt-s, success, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-case-sensitive, dt-cs, case_sensitive, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-exit, dt-e, exit, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-duration, dt-d, duration, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-throw, dt-nt, no_throw, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-exitcode, dt-ne, no_exitcode, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-run, dt-nr, no_run, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-version, dt-nv, no_version, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-colors, dt-nc, no_colors, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-force-colors, dt-fc, force_colors, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-breaks, dt-nb, no_breaks, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-skip, dt-ns, no_skip, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-path-filenames, dt-npf, no_path_in_filenames, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-line-numbers, dt-nln, no_line_numbers, false); - DOCTEST_PARSE_AS_BOOL_OR_FLAG(dt-no-skipped-summary, dt-nss, no_skipped_summary, false); -// clang-format on - -#undef DOCTEST_PARSE_STR_OPTION -#undef DOCTEST_PARSE_INT_OPTION -#undef DOCTEST_PARSE_AS_BOOL_OR_FLAG - - if(withDefaults) { - p->help = false; - p->version = false; - p->count = false; - p->list_test_cases = false; - p->list_test_suites = false; - } - if(parseFlag(argc, argv, "dt-help") || parseFlag(argc, argv, "dt-h") || - parseFlag(argc, argv, "dt-?")) { - p->help = true; - p->exit = true; - } - if(parseFlag(argc, argv, "dt-version") || parseFlag(argc, argv, "dt-v")) { - p->version = true; - p->exit = true; - } - if(parseFlag(argc, argv, "dt-count") || parseFlag(argc, argv, "dt-c")) { - p->count = true; - p->exit = true; - } - if(parseFlag(argc, argv, "dt-list-test-cases") || parseFlag(argc, argv, "dt-ltc")) { - p->list_test_cases = true; - p->exit = true; - } - if(parseFlag(argc, argv, "dt-list-test-suites") || parseFlag(argc, argv, "dt-lts")) { - p->list_test_suites = true; - p->exit = true; - } -} - -// allows the user to add procedurally to the filters from the command line -void Context::addFilter(const char* filter, const char* value) { setOption(filter, value); } - -// allows the user to clear all filters from the command line -void Context::clearFilters() { - for(unsigned i = 0; i < p->filters.size(); ++i) - p->filters[i].clear(); -} - -// allows the user to override procedurally the int/bool options from the command line -void Context::setOption(const char* option, int value) { - setOption(option, toString(value).c_str()); -} - -// allows the user to override procedurally the string options from the command line -void Context::setOption(const char* option, const char* value) { - String argv = String("-") + option + "=" + value; - const char* lvalue = argv.c_str(); - parseArgs(1, &lvalue); -} - -// users should query this in their main() and exit the program if true -bool Context::shouldExit() { return p->exit; } - -// the main function that does all the filtering and test running -int Context::run() { - using namespace detail; - - Color::init(); - - contextState = p; - p->resetRunData(); - - // handle version, help and no_run - if(p->no_run || p->version || p->help) { - if(p->version) - printVersion(); - if(p->help) - printHelp(); - - contextState = 0; - - return EXIT_SUCCESS; - } - - printVersion(); - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("run with \"--help\" for options\n"); - - unsigned i = 0; // counter used for loops - here for VC6 - - std::set& registeredTests = getRegisteredTests(); - - std::vector testArray; - for(std::set::iterator it = registeredTests.begin(); it != registeredTests.end(); - ++it) - testArray.push_back(&(*it)); - - // sort the collected records - if(!testArray.empty()) { - if(p->order_by.compare("file", true) == 0) { - std::qsort(&testArray[0], testArray.size(), sizeof(TestCase*), fileOrderComparator); - } else if(p->order_by.compare("suite", true) == 0) { - std::qsort(&testArray[0], testArray.size(), sizeof(TestCase*), suiteOrderComparator); - } else if(p->order_by.compare("name", true) == 0) { - std::qsort(&testArray[0], testArray.size(), sizeof(TestCase*), nameOrderComparator); - } else if(p->order_by.compare("rand", true) == 0) { - std::srand(p->rand_seed); - - // random_shuffle implementation - const TestCase** first = &testArray[0]; - for(i = testArray.size() - 1; i > 0; --i) { - int idxToSwap = std::rand() % (i + 1); // NOLINT - - const TestCase* temp = first[i]; - - first[i] = first[idxToSwap]; - first[idxToSwap] = temp; - } - } - } - - if(p->list_test_cases) { - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("listing all test case names\n"); - DOCTEST_PRINTF_COLORED(getSeparator(), Color::Yellow); - } - - std::set testSuitesPassingFilters; - if(p->list_test_suites) { - DOCTEST_PRINTF_COLORED("[doctest] ", Color::Cyan); - std::printf("listing all test suites\n"); - DOCTEST_PRINTF_COLORED(getSeparator(), Color::Yellow); - } - - // invoke the registered functions if they match the filter criteria (or just count them) - for(i = 0; i < testArray.size(); i++) { - const TestCase& data = *testArray[i]; - - if(data.m_skip && !p->no_skip) - continue; - - if(!matchesAny(data.m_file, p->filters[0], 1, p->case_sensitive)) - continue; - if(matchesAny(data.m_file, p->filters[1], 0, p->case_sensitive)) - continue; - if(!matchesAny(data.m_test_suite, p->filters[2], 1, p->case_sensitive)) - continue; - if(matchesAny(data.m_test_suite, p->filters[3], 0, p->case_sensitive)) - continue; - if(!matchesAny(data.m_name, p->filters[4], 1, p->case_sensitive)) - continue; - if(matchesAny(data.m_name, p->filters[5], 0, p->case_sensitive)) - continue; - - p->numTestsPassingFilters++; - - // do not execute the test if we are to only count the number of filter passing tests - if(p->count) - continue; - - // print the name of the test and don't execute it - if(p->list_test_cases) { - std::printf("%s\n", data.m_name); - continue; - } - - // print the name of the test suite if not done already and don't execute it - if(p->list_test_suites) { - if((testSuitesPassingFilters.count(data.m_test_suite) == 0) && - data.m_test_suite[0] != '\0') { - std::printf("%s\n", data.m_test_suite); - testSuitesPassingFilters.insert(data.m_test_suite); - p->numTestSuitesPassingFilters++; - } - continue; - } - - // skip the test if it is not in the execution range - if((p->last < p->numTestsPassingFilters && p->first <= p->last) || - (p->first > p->numTestsPassingFilters)) - continue; - - // execute the test if it passes all the filtering - { - p->currentTest = &data; - - bool failed = false; - p->hasLoggedCurrentTestStart = false; - p->numFailedAssertionsForCurrentTestcase = 0; - p->subcasesPassed.clear(); - double duration = 0; - Timer timer; - timer.start(); - do { - // if the start has been logged from a previous iteration of this loop - if(p->hasLoggedCurrentTestStart) - logTestEnd(); - p->hasLoggedCurrentTestStart = false; - - // if logging successful tests - force the start log - if(p->success) - DOCTEST_LOG_START(); - - // reset the assertion state - p->numAssertionsForCurrentTestcase = 0; - p->hasCurrentTestFailed = false; - - // reset some of the fields for subcases (except for the set of fully passed ones) - p->subcasesHasSkipped = false; - p->subcasesCurrentLevel = 0; - p->subcasesEnteredLevels.clear(); - - // reset stuff for logging with INFO() - p->exceptionalContexts.clear(); - -// execute the test -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS - try { -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - FatalConditionHandler fatalConditionHandler; // Handle signals - data.m_test(); - fatalConditionHandler.reset(); - if(contextState->hasCurrentTestFailed) - failed = true; -#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS - } catch(const TestFailureException&) { failed = true; } catch(...) { - DOCTEST_LOG_START(); - logTestException(translateActiveException()); - failed = true; - } -#endif // DOCTEST_CONFIG_NO_EXCEPTIONS - - p->numAssertions += p->numAssertionsForCurrentTestcase; - - // exit this loop if enough assertions have failed - if(p->abort_after > 0 && p->numFailedAssertions >= p->abort_after) { - p->subcasesHasSkipped = false; - DOCTEST_PRINTF_COLORED("Aborting - too many failed asserts!\n", Color::Red); - } - - } while(p->subcasesHasSkipped == true); - - duration = timer.getElapsedSeconds(); - - if(Approx(p->currentTest->m_timeout).epsilon(DBL_EPSILON) != 0 && - Approx(duration).epsilon(DBL_EPSILON) > p->currentTest->m_timeout) { - failed = true; - DOCTEST_LOG_START(); - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), - "Test case exceeded time limit of %.6f!\n", - p->currentTest->m_timeout); - DOCTEST_PRINTF_COLORED(msg, Color::Red); - } - - if(p->duration) { - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), "%.6f s: %s\n", duration, - p->currentTest->m_name); - DOCTEST_PRINTF_COLORED(msg, Color::None); - } - - if(data.m_should_fail) { - DOCTEST_LOG_START(); - if(failed) { - failed = false; - DOCTEST_PRINTF_COLORED("Failed as expected so marking it as not failed\n", - Color::Yellow); - } else { - failed = true; - DOCTEST_PRINTF_COLORED("Should have failed but didn't! Marking it as failed!\n", - Color::Red); - } - } else if(failed && data.m_may_fail) { - DOCTEST_LOG_START(); - failed = false; - DOCTEST_PRINTF_COLORED("Allowed to fail so marking it as not failed\n", - Color::Yellow); - } else if(data.m_expected_failures > 0) { - DOCTEST_LOG_START(); - char msg[DOCTEST_SNPRINTF_BUFFER_LENGTH]; - if(p->numFailedAssertionsForCurrentTestcase == data.m_expected_failures) { - failed = false; - DOCTEST_SNPRINTF( - msg, DOCTEST_COUNTOF(msg), - "Failed exactly %d times as expected so marking it as not failed!\n", - data.m_expected_failures); - DOCTEST_PRINTF_COLORED(msg, Color::Yellow); - } else { - failed = true; - DOCTEST_SNPRINTF(msg, DOCTEST_COUNTOF(msg), - "Didn't fail exactly %d times so marking it as failed!\n", - data.m_expected_failures); - DOCTEST_PRINTF_COLORED(msg, Color::Red); - } - } - - if(p->hasLoggedCurrentTestStart) - logTestEnd(); - - if(failed) // if any subcase has failed - the whole test case has failed - p->numFailed++; - - // stop executing tests if enough assertions have failed - if(p->abort_after > 0 && p->numFailedAssertions >= p->abort_after) - break; - } - } - - printSummary(); - - contextState = 0; - - if(p->numFailed && !p->no_exitcode) - return EXIT_FAILURE; - return EXIT_SUCCESS; -} -} // namespace doctest - -#endif // DOCTEST_CONFIG_DISABLE - -#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN -int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); } -#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN - -#endif // DOCTEST_LIBRARY_IMPLEMENTATION -#endif // DOCTEST_CONFIG_IMPLEMENT - -#if defined(__clang__) -#pragma clang diagnostic pop -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 6) -#pragma GCC diagnostic pop -#endif // > gcc 4.6 -#endif // __GNUC__ - -#ifdef _MSC_VER -#pragma warning(pop) -#endif // _MSC_VER diff --git a/tools/with-tee.bash b/tools/with-tee.bash index 60c33132..d968443e 100755 --- a/tools/with-tee.bash +++ b/tools/with-tee.bash @@ -1,4 +1,4 @@ -#!/bin/bash +#!/usr/bin/env bash echo "${@:2} | tee $1"