diff --git a/packages/CLI11/.github/actions/cmake_config/Dockerfile b/packages/CLI11/.github/actions/cmake_config/Dockerfile
deleted file mode 100644
index 63b28a9949de219993f26a48d85db4afe6bce6df..0000000000000000000000000000000000000000
--- a/packages/CLI11/.github/actions/cmake_config/Dockerfile
+++ /dev/null
@@ -1,16 +0,0 @@
-FROM ubuntu:18.04
-
-RUN apt-get update \
- && apt-get install -y --no-install-recommends \
- g++=4:7.4.0-1ubuntu2.3 \
- wget=1.19.4-1ubuntu2.2 \
- libidn11=1.33-2.1ubuntu1.2 \
- ca-certificates=20180409 \
- make=4.1-9.1ubuntu1 \
- git=1:2.17.1-1ubuntu0.7 \
- && apt-get clean \
- && rm -rf /var/lib/apt/lists/*
-
-COPY entrypoint.sh /entrypoint.sh
-
-ENTRYPOINT ["/entrypoint.sh"]
diff --git a/packages/CLI11/.github/actions/cmake_config/action.yml b/packages/CLI11/.github/actions/cmake_config/action.yml
deleted file mode 100644
index 73ff1661b5a6fe2840339996cf88671bc1053b67..0000000000000000000000000000000000000000
--- a/packages/CLI11/.github/actions/cmake_config/action.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-description: 'Test out a bare bones configuration with a CMake version'
-inputs:
- version:
- description: 'The full version of CMake to check'
- required: true
- options:
- description: 'The CMake configuration options'
- required: false
- default: ""
-name: 'Configure with CMake'
-runs:
- using: 'docker'
- image: 'Dockerfile'
- args:
- - ${{ inputs.version }}
- - ${{ inputs.options }}
diff --git a/packages/CLI11/.github/actions/cmake_config/entrypoint.sh b/packages/CLI11/.github/actions/cmake_config/entrypoint.sh
deleted file mode 100755
index e3bd622e1575375a746dc9425a7012b1777a79f1..0000000000000000000000000000000000000000
--- a/packages/CLI11/.github/actions/cmake_config/entrypoint.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/bash -l
-
-set -ex
-
-mkdir -p cmake_dir
-mkdir -p build_tmp
-mkdir -p cmake_sources
-rm -rf cmake_dir/* build_tmp/*
-
-v=$1
-fn=cmake-$v-Linux-x86_64.tar.gz
-
-if [ ! -f cmake_sources/$fn ]; then
- wget -qO cmake_sources/$fn "https://cmake.org/files/v${v%.*}/$fn"
-fi
-
-tar -xzf cmake_sources/$fn --strip-components=1 -C $PWD/cmake_dir
-
-export PATH=$PWD/cmake_dir/bin:$PATH
-
-cmake --version
-
-cd build_tmp && cmake .. $2
diff --git a/packages/CLI11/.github/actions/quick_cmake/action.yml b/packages/CLI11/.github/actions/quick_cmake/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..da721a78c32e275b7f8c93e7a8457b1d009925fc
--- /dev/null
+++ b/packages/CLI11/.github/actions/quick_cmake/action.yml
@@ -0,0 +1,18 @@
+name: Quick CMake config
+description: 'Runs CMake 3.4+ (if already setup)'
+inputs:
+ args:
+ description: 'Other arguments'
+ required: false
+ default: ''
+
+runs:
+ using: composite
+ steps:
+ - run: |
+ mkdir -p build-tmp
+ touch build-tmp/tmp
+ rm -r build-tmp/*
+ (cd build-tmp && cmake .. ${{ inputs.args}})
+ rm -r build-tmp
+ shell: bash
diff --git a/packages/CLI11/.github/workflows/tests.yml b/packages/CLI11/.github/workflows/tests.yml
index 9fcfc705b2860f8ff85464eae2562ae90229f123..60f10f9623eaf0218344a63d60737eea92d5ace2 100644
--- a/packages/CLI11/.github/workflows/tests.yml
+++ b/packages/CLI11/.github/workflows/tests.yml
@@ -15,7 +15,7 @@ jobs:
steps:
- uses: actions/checkout@v2
- uses: actions/setup-python@v2
- - uses: pre-commit/action@v2.0.0
+ - uses: pre-commit/action@v2.0.2
cuda-build:
name: CUDA build only
@@ -28,7 +28,7 @@ jobs:
- name: Add wget
run: apt-get update && apt-get install -y wget
- name: Setup cmake
- uses: jwlawson/actions-setup-cmake@v1.7
+ uses: jwlawson/actions-setup-cmake@v1.8
- name: Configure
run: cmake -S . -B build -DCLI11_CUDA_TESTS=ON
- name: Build
@@ -39,81 +39,144 @@ jobs:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- with:
- submodules: true
+
- name: CMake 3.4
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.4.3
+ cmake-version: "3.4"
+ - name: Check CMake 3.4
+ uses: ./.github/actions/quick_cmake
+
- name: CMake 3.5
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.5.2
+ cmake-version: "3.5"
+ - name: Check CMake 3.5
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.6
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.6.3
+ cmake-version: "3.6"
+ - name: Check CMake 3.6
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.7
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.7.2
+ cmake-version: "3.7"
+ - name: Check CMake 3.7
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.8
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.8.2
+ cmake-version: "3.8"
+ - name: Check CMake 3.8
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.9
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.9.6
+ cmake-version: "3.9"
+ - name: Check CMake 3.9
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.10
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.10.3
+ cmake-version: "3.10"
+ - name: Check CMake 3.10
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
- - name: CMake 3.11 (full)
- uses: ./.github/actions/cmake_config
+
+ - name: CMake 3.11
+ uses: jwlawson/actions-setup-cmake@v1.8
+ with:
+ cmake-version: "3.11"
+ - name: Check CMake 3.11 (full)
+ uses: ./.github/actions/quick_cmake
with:
- version: 3.11.4
- options: -DCLI11_SANITIZERS=ON -DCLI11_BUILD_EXAMPLES_JSON=ON
+ args: -DCLI11_SANITIZERS=ON -DCLI11_BUILD_EXAMPLES_JSON=ON
if: success() || failure()
+
- name: CMake 3.12
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.12.4
+ cmake-version: "3.12"
+ - name: Check CMake 3.12
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.13
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.13.5
+ cmake-version: "3.13"
+ - name: Check CMake 3.13
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.14
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.14.7
+ cmake-version: "3.14"
+ - name: Check CMake 3.14
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.15
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.15.6
+ cmake-version: "3.15"
+ - name: Check CMake 3.15
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.16
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.16.8
+ cmake-version: "3.16"
+ - name: Check CMake 3.16
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
- name: CMake 3.17
- uses: ./.github/actions/cmake_config
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.17.3
+ cmake-version: "3.17"
+ - name: Check CMake 3.17
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
- - name: CMake 3.18 (full)
- uses: ./.github/actions/cmake_config
+
+ - name: CMake 3.18
+ uses: jwlawson/actions-setup-cmake@v1.8
with:
- version: 3.18.0
- options: -DCLI11_SANITIZERS=ON -DCLI11_BUILD_EXAMPLES_JSON=ON
+ cmake-version: "3.18"
+ - name: Check CMake 3.18
+ uses: ./.github/actions/quick_cmake
if: success() || failure()
+
+ - name: CMake 3.19
+ uses: jwlawson/actions-setup-cmake@v1.8
+ with:
+ cmake-version: "3.19"
+ - name: Check CMake 3.19 (full)
+ uses: ./.github/actions/quick_cmake
+ with:
+ args: -DCLI11_SANITIZERS=ON -DCLI11_BUILD_EXAMPLES_JSON=ON
+ if: success() || failure()
+
+ - name: CMake 3.20
+ uses: jwlawson/actions-setup-cmake@v1.8
+ with:
+ cmake-version: "3.20"
+ - name: Check CMake 3.20
+ uses: ./.github/actions/quick_cmake
+ if: success() || failure()
+
+
diff --git a/packages/CLI11/.gitignore b/packages/CLI11/.gitignore
index 2a6ef59a35af60bd3b7ae6ec675f2b045fd8dfbb..cc1b9d0c7f77776f258bfccbe82224fe588e9582 100644
--- a/packages/CLI11/.gitignore
+++ b/packages/CLI11/.gitignore
@@ -12,3 +12,4 @@ a.out*
/node_modules/*
/package.json
/yarn.lock
+/CLI11.hpp
diff --git a/packages/CLI11/.gitmodules b/packages/CLI11/.gitmodules
deleted file mode 100644
index 6051b7f20049a412a56aa8f664a56a8e35b0278f..0000000000000000000000000000000000000000
--- a/packages/CLI11/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "extern/googletest"]
- path = extern/googletest
- url = ../../google/googletest.git
diff --git a/packages/CLI11/.gitrepo b/packages/CLI11/.gitrepo
index e423eb3eead27d0875cc8ea21a30bf8ceec6ed8c..732e03b962d7b98a783a3ae9f93d8ac9232673e5 100644
--- a/packages/CLI11/.gitrepo
+++ b/packages/CLI11/.gitrepo
@@ -6,7 +6,7 @@
[subrepo]
remote = git@github.com:CLIUtils/CLI11.git
branch = master
- commit = 639a8add1e248c7337b420ff68572ddb3893e080
- parent = b7068f18e2c214064a81a5b561d5f04a80d2a847
+ commit = 4af78beef777e313814b4daff70e2da9171a385a
+ parent = 015d2fd5332b347d28c47c8dfe3f401382724178
cmdver = 0.4.3
method = merge
diff --git a/packages/CLI11/CHANGELOG.md b/packages/CLI11/CHANGELOG.md
index f9cc853b7f3bf554c2743b98de8f6fe53e610617..d2a59b4786a836a07801228e5371e095b42c5e23 100644
--- a/packages/CLI11/CHANGELOG.md
+++ b/packages/CLI11/CHANGELOG.md
@@ -1,14 +1,42 @@
## Version 2.0: In progress
-* Built-in config format is TOML compliant now [#435]
-* Config updates [#442]
-* More powerful containers, `%%` separator [#423]
-* Add a version flag easily [#452]
+* Built-in config format is TOML compliant now [#435][]
+ * Support multiline TOML [#528][]
+* Support short/positional options in config mode [#443][]
+* More powerful containers, `%%` separator [#423][]
+* Add a version flag easily [#452][]
+* Support atomic types [#520][]
+* Add a type validator `CLI::TypeValidator<TYPE>` [#526][]
+* Support `->silent()` on subcommands. [#529][]
+* Add alias section to help for subcommands [#545][]
+* Redesigned MakeSingleFiles to have a higher level of manual control, to support future features. [#546][]
+* Moved testing from GTest to Catch2 [#574][]
+
+* Bugfix: avoid listing helpall as a required flag [#530][]
+* Bugfix: avoid a clash with WINDOWS define [#563][]
+
+* Removed deprecated set commands, use validators instead. [#565][]
+
+* Build: support pkg-config [#523][]
+
[#435]: https://github.com/CLIUtils/CLI11/pull/435
[#443]: https://github.com/CLIUtils/CLI11/pull/443
[#423]: https://github.com/CLIUtils/CLI11/pull/423
[#452]: https://github.com/CLIUtils/CLI11/pull/452
+[#520]: https://github.com/CLIUtils/CLI11/pull/520
+[#523]: https://github.com/CLIUtils/CLI11/pull/523
+[#526]: https://github.com/CLIUtils/CLI11/pull/526
+[#528]: https://github.com/CLIUtils/CLI11/pull/528
+[#529]: https://github.com/CLIUtils/CLI11/pull/529
+[#530]: https://github.com/CLIUtils/CLI11/pull/530
+[#545]: https://github.com/CLIUtils/CLI11/pull/545
+[#546]: https://github.com/CLIUtils/CLI11/pull/546
+[#563]: https://github.com/CLIUtils/CLI11/pull/563
+[#565]: https://github.com/CLIUtils/CLI11/pull/565
+[#574]: https://github.com/CLIUtils/CLI11/pull/574
+
+
### Version 1.9.1: Backporting fixes
diff --git a/packages/CLI11/CPPLINT.cfg b/packages/CLI11/CPPLINT.cfg
index d497667bbc899dc8056d25387413cd382d7737f9..0a1758da0e5b703d4677bcaf60d171455c4aee66 100644
--- a/packages/CLI11/CPPLINT.cfg
+++ b/packages/CLI11/CPPLINT.cfg
@@ -5,6 +5,8 @@ linelength=120 # As in .clang-format
filter=-build/c++11 # Reports e.g. chrono and thread, which overlap with Chromium's API. Not applicable to general C++ projects.
filter=-build/include_order # Requires unusual include order that encourages creating not self-contained headers
filter=-readability/nolint # Conflicts with clang-tidy
+filter=-readability/check # Catch uses CHECK(a == b) (Tests only)
+filter=-build/namespaces # Currently using it for one test (Tests only)
filter=-runtime/references # Requires fundamental change of API, don't see need for this
filter=-whitespace/blank_line # Unnecessarily strict with blank lines that otherwise help with readability
filter=-whitespace/indent # Requires strange 3-space indent of private/protected/public markers
diff --git a/packages/CLI11/README.md b/packages/CLI11/README.md
index 8ffb6b25ddd02583763cb18dcd4902ca221a8b63..846d44ec7310e567fa32897088c03d659d1e3b56 100644
--- a/packages/CLI11/README.md
+++ b/packages/CLI11/README.md
@@ -224,7 +224,7 @@ While all options internally are the same type, there are several ways to add an
app.add_option(option_name, help_str="")
app.add_option(option_name,
- variable_to_bind_to, // bool, char(see note)๐ง, int, float, vector, enum, or string-like, or anything with a defined conversion from a string or that takes an int ๐, double ๐, or string in a constructor. Also allowed are tuples ๐, std::array ๐ or std::pair ๐. Also supported are complex numbers๐ง, wrapper types๐ง, and containers besides vector๐ง of any other supported type.
+ variable_to_bind_to, // bool, char(see note)๐ง, int, float, vector, enum, std::atomic ๐ง, or string-like, or anything with a defined conversion from a string or that takes an int ๐, double ๐, or string in a constructor. Also allowed are tuples ๐, std::array ๐ or std::pair ๐. Also supported are complex numbers๐ง, wrapper types๐ง, and containers besides vector๐ง of any other supported type.
help_string="")
app.add_option_function<type>(option_name,
@@ -245,7 +245,7 @@ app.add_flag(option_name,
help_string="")
app.add_flag(option_name,
- variable_to_bind_to, // bool, int, float, complex, containers, enum, or string-like, or any singular object with a defined conversion from a string like add_option
+ variable_to_bind_to, // bool, int, float, complex, containers, enum, std::atomic ๐ง, or string-like, or any singular object with a defined conversion from a string like add_option
help_string="")
app.add_flag_function(option_name,
diff --git a/packages/CLI11/azure-pipelines.yml b/packages/CLI11/azure-pipelines.yml
index 90017c62f8f111acfa4eb95c78f07d2c1453fd9c..c72c748e6f59d6af651e28231b6cbb0d53f8a32d 100644
--- a/packages/CLI11/azure-pipelines.yml
+++ b/packages/CLI11/azure-pipelines.yml
@@ -121,7 +121,7 @@ jobs:
cli11.std: 17
cli11.options: -DCLI11_FORCE_LIBCXX=ON
clang10_20:
- containerImage: helics/buildenv:clang10-builder
+ containerImage: silkeh/clang:10
cli11.std: 20
cli11.options: -DCLI11_FORCE_LIBCXX=ON -DCMAKE_CXX_FLAGS=-std=c++20
container: $[ variables['containerImage'] ]
diff --git a/packages/CLI11/cmake/AddGoogletest.cmake b/packages/CLI11/cmake/AddGoogletest.cmake
deleted file mode 100644
index ae0dc18fcb96f974148645e2ab2fb0abc8efe564..0000000000000000000000000000000000000000
--- a/packages/CLI11/cmake/AddGoogletest.cmake
+++ /dev/null
@@ -1,49 +0,0 @@
-#
-#
-# Includes GTest and provides a helper macro to add tests. Add make check, as well, which
-# gives output on failed tests without having to set an environment variable.
-#
-#
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-set(BUILD_SHARED_LIBS OFF)
-
-add_subdirectory("${CLI11_SOURCE_DIR}/extern/googletest" "${CLI11_BINARY_DIR}/extern/googletest" EXCLUDE_FROM_ALL)
-
-
-if(GOOGLE_TEST_INDIVIDUAL)
- if(NOT CMAKE_VERSION VERSION_LESS 3.9)
- include(GoogleTest)
- else()
- set(GOOGLE_TEST_INDIVIDUAL OFF)
- endif()
-endif()
-
-# Target must already exist
-macro(add_gtest TESTNAME)
- target_link_libraries(${TESTNAME} PUBLIC gtest gmock gtest_main)
-
- if(GOOGLE_TEST_INDIVIDUAL)
- if(CMAKE_VERSION VERSION_LESS 3.10)
- gtest_add_tests(TARGET ${TESTNAME}
- TEST_PREFIX "${TESTNAME}."
- TEST_LIST TmpTestList)
- set_tests_properties(${TmpTestList} PROPERTIES FOLDER "Tests")
- else()
- gtest_discover_tests(${TESTNAME}
- TEST_PREFIX "${TESTNAME}."
- PROPERTIES FOLDER "Tests")
-
- endif()
- else()
- add_test(${TESTNAME} ${TESTNAME})
- set_target_properties(${TESTNAME} PROPERTIES FOLDER "Tests")
- if (CLI11_FORCE_LIBCXX)
- set_property(TARGET ${T} APPEND_STRING
- PROPERTY LINK_FLAGS -stdlib=libc++)
- endif()
- endif()
-
-endmacro()
-
-set_target_properties(gtest gtest_main gmock gmock_main
- PROPERTIES FOLDER "Extern")
diff --git a/packages/CLI11/extern/googletest b/packages/CLI11/extern/googletest
deleted file mode 160000
index 859bfe8981d6724c4ea06e73d29accd8588f3230..0000000000000000000000000000000000000000
--- a/packages/CLI11/extern/googletest
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 859bfe8981d6724c4ea06e73d29accd8588f3230
diff --git a/packages/CLI11/include/CLI/App.hpp b/packages/CLI11/include/CLI/App.hpp
index d3c513bd03de33141eafa41ea176fe742992e69d..edbe2b7386ba7be718762c034fa2c3d3bf87ce9b 100644
--- a/packages/CLI11/include/CLI/App.hpp
+++ b/packages/CLI11/include/CLI/App.hpp
@@ -44,7 +44,7 @@ namespace CLI {
#endif
namespace detail {
-enum class Classifier { NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS, SUBCOMMAND, SUBCOMMAND_TERMINATOR };
+enum class Classifier { NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS_STYLE, SUBCOMMAND, SUBCOMMAND_TERMINATOR };
struct AppFriend;
} // namespace detail
@@ -897,56 +897,6 @@ class App {
}
#endif
- /// Add set of options (No default, temp reference, such as an inline set) DEPRECATED
- template <typename T>
- Option *add_set(std::string option_name,
- T &member, ///< The selected member of the set
- std::set<T> options, ///< The set of possibilities
- std::string option_description = "") {
-
- Option *opt = add_option(option_name, member, std::move(option_description));
- opt->check(IsMember{options});
- return opt;
- }
-
- /// Add set of options (No default, set can be changed afterwards - do not destroy the set) DEPRECATED
- template <typename T>
- Option *add_mutable_set(std::string option_name,
- T &member, ///< The selected member of the set
- const std::set<T> &options, ///< The set of possibilities
- std::string option_description = "") {
-
- Option *opt = add_option(option_name, member, std::move(option_description));
- opt->check(IsMember{&options});
- return opt;
- }
-
- /// Add set of options (with default, static set, such as an inline set) DEPRECATED
- template <typename T>
- Option *add_set(std::string option_name,
- T &member, ///< The selected member of the set
- std::set<T> options, ///< The set of possibilities
- std::string option_description,
- bool defaulted) {
-
- Option *opt = add_option(option_name, member, std::move(option_description), defaulted);
- opt->check(IsMember{options});
- return opt;
- }
-
- /// Add set of options (with default, set can be changed afterwards - do not destroy the set) DEPRECATED
- template <typename T>
- Option *add_mutable_set(std::string option_name,
- T &member, ///< The selected member of the set
- const std::set<T> &options, ///< The set of possibilities
- std::string option_description,
- bool defaulted) {
-
- Option *opt = add_option(option_name, member, std::move(option_description), defaulted);
- opt->check(IsMember{&options});
- return opt;
- }
-
/// Add a complex number DEPRECATED --use add_option instead
template <typename T, typename XC = double>
Option *add_complex(std::string option_name,
@@ -2072,7 +2022,7 @@ class App {
return detail::Classifier::SHORT;
}
if((allow_windows_style_options_) && (detail::split_windows_style(current, dummy1, dummy2)))
- return detail::Classifier::WINDOWS;
+ return detail::Classifier::WINDOWS_STYLE;
if((current == "++") && !name_.empty() && parent_ != nullptr)
return detail::Classifier::SUBCOMMAND_TERMINATOR;
return detail::Classifier::NONE;
@@ -2525,7 +2475,7 @@ class App {
break;
case detail::Classifier::LONG:
case detail::Classifier::SHORT:
- case detail::Classifier::WINDOWS:
+ case detail::Classifier::WINDOWS_STYLE:
// If already parsed a subcommand, don't accept options_
_parse_arg(args, classifier);
break;
@@ -2742,7 +2692,7 @@ class App {
if(!detail::split_short(current, arg_name, rest))
throw HorribleError("Short parsed but missing! You should not see this");
break;
- case detail::Classifier::WINDOWS:
+ case detail::Classifier::WINDOWS_STYLE:
if(!detail::split_windows_style(current, arg_name, value))
throw HorribleError("windows option parsed but missing! You should not see this");
break;
@@ -2760,7 +2710,7 @@ class App {
return opt->check_lname(arg_name);
if(current_type == detail::Classifier::SHORT)
return opt->check_sname(arg_name);
- // this will only get called for detail::Classifier::WINDOWS
+ // this will only get called for detail::Classifier::WINDOWS_STYLE
return opt->check_lname(arg_name) || opt->check_sname(arg_name);
});
diff --git a/packages/CLI11/tests/AppTest.cpp b/packages/CLI11/tests/AppTest.cpp
index 89f52c0853354280eee2745920a92b290a55fe4f..6c3e71ced8ee59cbe4409698b86b44b56430a881 100644
--- a/packages/CLI11/tests/AppTest.cpp
+++ b/packages/CLI11/tests/AppTest.cpp
@@ -9,129 +9,127 @@
#include <cstdint>
#include <cstdlib>
-#include "gmock/gmock.h"
-
-TEST_F(TApp, OneFlagShort) {
+TEST_CASE_METHOD(TApp, "OneFlagShort", "[app]") {
app.add_flag("-c,--count");
args = {"-c"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
}
-TEST_F(TApp, OneFlagShortValues) {
+TEST_CASE_METHOD(TApp, "OneFlagShortValues", "[app]") {
app.add_flag("-c{v1},--count{v2}");
args = {"-c"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
auto v = app["-c"]->results();
- EXPECT_EQ(v[0], "v1");
+ CHECK("v1" == v[0]);
- EXPECT_THROW(app["--invalid"], CLI::OptionNotFound);
+ CHECK_THROWS_AS(app["--invalid"], CLI::OptionNotFound);
}
-TEST_F(TApp, OneFlagShortValuesAs) {
+TEST_CASE_METHOD(TApp, "OneFlagShortValuesAs", "[app]") {
auto flg = app.add_flag("-c{1},--count{2}");
args = {"-c"};
run();
auto opt = app["-c"];
- EXPECT_EQ(opt->as<int>(), 1);
+ CHECK(1 == opt->as<int>());
args = {"--count"};
run();
- EXPECT_EQ(opt->as<int>(), 2);
+ CHECK(2 == opt->as<int>());
flg->take_first();
args = {"-c", "--count"};
run();
- EXPECT_EQ(opt->as<int>(), 1);
+ CHECK(1 == opt->as<int>());
flg->take_last();
- EXPECT_EQ(opt->as<int>(), 2);
+ CHECK(2 == opt->as<int>());
flg->multi_option_policy(CLI::MultiOptionPolicy::Throw);
- EXPECT_THROW(opt->as<int>(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(opt->as<int>(), CLI::ArgumentMismatch);
flg->multi_option_policy(CLI::MultiOptionPolicy::TakeAll);
auto vec = opt->as<std::vector<int>>();
- EXPECT_EQ(vec[0], 1);
- EXPECT_EQ(vec[1], 2);
+ CHECK(1 == vec[0]);
+ CHECK(2 == vec[1]);
flg->multi_option_policy(CLI::MultiOptionPolicy::Join);
- EXPECT_EQ(opt->as<std::string>(), "1\n2");
+ CHECK("1\n2" == opt->as<std::string>());
flg->delimiter(',');
- EXPECT_EQ(opt->as<std::string>(), "1,2");
+ CHECK("1,2" == opt->as<std::string>());
}
-TEST_F(TApp, OneFlagShortWindows) {
+TEST_CASE_METHOD(TApp, "OneFlagShortWindows", "[app]") {
app.add_flag("-c,--count");
args = {"/c"};
app.allow_windows_style_options();
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
}
-TEST_F(TApp, WindowsLongShortMix1) {
+TEST_CASE_METHOD(TApp, "WindowsLongShortMix1", "[app]") {
app.allow_windows_style_options();
auto a = app.add_flag("-c");
auto b = app.add_flag("--c");
args = {"/c"};
run();
- EXPECT_EQ(1u, a->count());
- EXPECT_EQ(0u, b->count());
+ CHECK(a->count() == 1u);
+ CHECK(b->count() == 0u);
}
-TEST_F(TApp, WindowsLongShortMix2) {
+TEST_CASE_METHOD(TApp, "WindowsLongShortMix2", "[app]") {
app.allow_windows_style_options();
auto a = app.add_flag("--c");
auto b = app.add_flag("-c");
args = {"/c"};
run();
- EXPECT_EQ(1u, a->count());
- EXPECT_EQ(0u, b->count());
+ CHECK(a->count() == 1u);
+ CHECK(b->count() == 0u);
}
-TEST_F(TApp, CountNonExist) {
+TEST_CASE_METHOD(TApp, "CountNonExist", "[app]") {
app.add_flag("-c,--count");
args = {"-c"};
run();
- EXPECT_THROW(app.count("--nonexist"), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app.count("--nonexist"), CLI::OptionNotFound);
}
-TEST_F(TApp, OneFlagLong) {
+TEST_CASE_METHOD(TApp, "OneFlagLong", "[app]") {
app.add_flag("-c,--count");
args = {"--count"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
}
-TEST_F(TApp, DashedOptions) {
+TEST_CASE_METHOD(TApp, "DashedOptions", "[app]") {
app.add_flag("-c");
app.add_flag("--q");
app.add_flag("--this,--that");
args = {"-c", "--q", "--this", "--that"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--q"));
- EXPECT_EQ(2u, app.count("--this"));
- EXPECT_EQ(2u, app.count("--that"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--q") == 1u);
+ CHECK(app.count("--this") == 2u);
+ CHECK(app.count("--that") == 2u);
}
-TEST_F(TApp, DashedOptionsSingleString) {
+TEST_CASE_METHOD(TApp, "DashedOptionsSingleString", "[app]") {
app.add_flag("-c");
app.add_flag("--q");
app.add_flag("--this,--that");
app.parse("-c --q --this --that");
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--q"));
- EXPECT_EQ(2u, app.count("--this"));
- EXPECT_EQ(2u, app.count("--that"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--q") == 1u);
+ CHECK(app.count("--this") == 2u);
+ CHECK(app.count("--that") == 2u);
}
-TEST_F(TApp, RequireOptionsError) {
- using ::testing::HasSubstr;
- using ::testing::Not;
+TEST_CASE_METHOD(TApp, "RequireOptionsError", "[app]") {
+ using Catch::Matchers::Contains;
+
app.add_flag("-c");
app.add_flag("--q");
app.add_flag("--this,--that");
@@ -141,267 +139,267 @@ TEST_F(TApp, RequireOptionsError) {
try {
app.parse("-c --q --this --that");
} catch(const CLI::RequiredError &re) {
- EXPECT_THAT(re.what(), Not(HasSubstr("-h,--help")));
- EXPECT_THAT(re.what(), Not(HasSubstr("help_all")));
+ CHECK_THAT(re.what(), !Contains("-h,--help"));
+ CHECK_THAT(re.what(), !Contains("help_all"));
}
- EXPECT_NO_THROW(app.parse("-c --q"));
- EXPECT_NO_THROW(app.parse("-c --this --that"));
+ CHECK_NOTHROW(app.parse("-c --q"));
+ CHECK_NOTHROW(app.parse("-c --this --that"));
}
-TEST_F(TApp, BoolFlagOverride) {
+TEST_CASE_METHOD(TApp, "BoolFlagOverride", "[app]") {
bool val{false};
auto flg = app.add_flag("--this,--that", val);
app.parse("--this");
- EXPECT_TRUE(val);
+ CHECK(val);
app.parse("--this=false");
- EXPECT_FALSE(val);
+ CHECK(!val);
flg->disable_flag_override(true);
app.parse("--this");
- EXPECT_TRUE(val);
+ CHECK(val);
// this is allowed since the matching string is the default
app.parse("--this=true");
- EXPECT_TRUE(val);
+ CHECK(val);
- EXPECT_THROW(app.parse("--this=false"), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(app.parse("--this=false"), CLI::ArgumentMismatch);
// try a string that specifies 'use default val'
- EXPECT_NO_THROW(app.parse("--this={}"));
+ CHECK_NOTHROW(app.parse("--this={}"));
}
-TEST_F(TApp, OneFlagRef) {
+TEST_CASE_METHOD(TApp, "OneFlagRef", "[app]") {
int ref{0};
app.add_flag("-c,--count", ref);
args = {"--count"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
- EXPECT_EQ(1, ref);
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
+ CHECK(ref == 1);
}
-TEST_F(TApp, OneFlagRefValue) {
+TEST_CASE_METHOD(TApp, "OneFlagRefValue", "[app]") {
int ref{0};
app.add_flag("-c,--count", ref);
args = {"--count=7"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
- EXPECT_EQ(7, ref);
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
+ CHECK(ref == 7);
}
-TEST_F(TApp, OneFlagRefValueFalse) {
+TEST_CASE_METHOD(TApp, "OneFlagRefValueFalse", "[app]") {
int ref{0};
auto flg = app.add_flag("-c,--count", ref);
args = {"--count=false"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
- EXPECT_EQ(-1, ref);
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
+ CHECK(ref == -1);
- EXPECT_FALSE(flg->check_fname("c"));
+ CHECK(!flg->check_fname("c"));
args = {"--count=0"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
- EXPECT_EQ(-1, ref);
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
+ CHECK(ref == -1);
args = {"--count=happy"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, FlagNegation) {
+TEST_CASE_METHOD(TApp, "FlagNegation", "[app]") {
int ref{0};
auto flg = app.add_flag("-c,--count,--ncount{false}", ref);
args = {"--count", "-c", "--ncount"};
- EXPECT_FALSE(flg->check_fname("count"));
- EXPECT_TRUE(flg->check_fname("ncount"));
+ CHECK(!flg->check_fname("count"));
+ CHECK(flg->check_fname("ncount"));
run();
- EXPECT_EQ(3u, app.count("-c"));
- EXPECT_EQ(3u, app.count("--count"));
- EXPECT_EQ(3u, app.count("--ncount"));
- EXPECT_EQ(1, ref);
+ CHECK(app.count("-c") == 3u);
+ CHECK(app.count("--count") == 3u);
+ CHECK(app.count("--ncount") == 3u);
+ CHECK(ref == 1);
}
-TEST_F(TApp, FlagNegationShortcutNotation) {
+TEST_CASE_METHOD(TApp, "FlagNegationShortcutNotation", "[app]") {
int ref{0};
app.add_flag("-c,--count{true},!--ncount", ref);
args = {"--count=TRUE", "-c", "--ncount"};
run();
- EXPECT_EQ(3u, app.count("-c"));
- EXPECT_EQ(3u, app.count("--count"));
- EXPECT_EQ(3u, app.count("--ncount"));
- EXPECT_EQ(1, ref);
+ CHECK(app.count("-c") == 3u);
+ CHECK(app.count("--count") == 3u);
+ CHECK(app.count("--ncount") == 3u);
+ CHECK(ref == 1);
}
-TEST_F(TApp, FlagNegationShortcutNotationInvalid) {
+TEST_CASE_METHOD(TApp, "FlagNegationShortcutNotationInvalid", "[app]") {
int ref{0};
app.add_flag("-c,--count,!--ncount", ref);
args = {"--ncount=happy"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, OneString) {
+TEST_CASE_METHOD(TApp, "OneString", "[app]") {
std::string str;
app.add_option("-s,--string", str);
args = {"--string", "mystring"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringWindowsStyle) {
+TEST_CASE_METHOD(TApp, "OneStringWindowsStyle", "[app]") {
std::string str;
app.add_option("-s,--string", str);
args = {"/string", "mystring"};
app.allow_windows_style_options();
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringSingleStringInput) {
+TEST_CASE_METHOD(TApp, "OneStringSingleStringInput", "[app]") {
std::string str;
app.add_option("-s,--string", str);
app.parse("--string mystring");
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringEqualVersion) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersion", "[app]") {
std::string str;
app.add_option("-s,--string", str);
args = {"--string=mystring"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringEqualVersionWindowsStyle) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionWindowsStyle", "[app]") {
std::string str;
app.add_option("-s,--string", str);
args = {"/string:mystring"};
app.allow_windows_style_options();
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringEqualVersionSingleString) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleString", "[app]") {
std::string str;
app.add_option("-s,--string", str);
app.parse("--string=mystring");
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuoted) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuoted", "[app]") {
std::string str;
app.add_option("-s,--string", str);
app.parse(R"raw(--string="this is my quoted string")raw");
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "this is my quoted string");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("this is my quoted string" == str);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultiple) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuotedMultiple", "[app]") {
std::string str, str2, str3;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("-m,--mstr", str3);
app.parse(R"raw(--string="this is my quoted string" -t 'qstring 2' -m=`"quoted string"`)raw");
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringEmbeddedEqual) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringEmbeddedEqual", "[app]") {
std::string str, str2, str3;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("-m,--mstr", str3);
app.parse(R"raw(--string="app=\"test1 b\" test2=\"frogs\"" -t 'qstring 2' -m=`"quoted string"`)raw");
- EXPECT_EQ(str, "app=\"test1 b\" test2=\"frogs\"");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("app=\"test1 b\" test2=\"frogs\"" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
app.parse(R"raw(--string="app='test1 b' test2='frogs'" -t 'qstring 2' -m=`"quoted string"`)raw");
- EXPECT_EQ(str, "app='test1 b' test2='frogs'");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("app='test1 b' test2='frogs'" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringEmbeddedEqualWindowsStyle) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringEmbeddedEqualWindowsStyle", "[app]") {
std::string str, str2, str3;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("--mstr", str3);
app.allow_windows_style_options();
app.parse(R"raw(/string:"app:\"test1 b\" test2:\"frogs\"" /t 'qstring 2' /mstr:`"quoted string"`)raw");
- EXPECT_EQ(str, "app:\"test1 b\" test2:\"frogs\"");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("app:\"test1 b\" test2:\"frogs\"" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
app.parse(R"raw(/string:"app:'test1 b' test2:'frogs'" /t 'qstring 2' /mstr:`"quoted string"`)raw");
- EXPECT_EQ(str, "app:'test1 b' test2:'frogs'");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("app:'test1 b' test2:'frogs'" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleMixedStyle) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuotedMultipleMixedStyle", "[app]") {
std::string str, str2, str3;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("-m,--mstr", str3);
app.allow_windows_style_options();
app.parse(R"raw(/string:"this is my quoted string" /t 'qstring 2' -m=`"quoted string"`)raw");
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleInMiddle) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuotedMultipleInMiddle", "[app]") {
std::string str, str2, str3;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("-m,--mstr", str3);
app.parse(R"raw(--string="this is my quoted string" -t "qst\"ring 2" -m=`"quoted string"`)raw");
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qst\"ring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("this is my quoted string" == str);
+ CHECK("qst\"ring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuotedEscapedCharacters) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuotedEscapedCharacters", "[app]") {
std::string str, str2, str3;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("-m,--mstr", str3);
app.parse(R"raw(--string="this is my \"quoted\" string" -t 'qst\'ring 2' -m=`"quoted\` string"`")raw");
- EXPECT_EQ(str, "this is my \"quoted\" string");
- EXPECT_EQ(str2, "qst\'ring 2");
- EXPECT_EQ(str3, "\"quoted` string\"");
+ CHECK("this is my \"quoted\" string" == str);
+ CHECK("qst\'ring 2" == str2);
+ CHECK("\"quoted` string\"" == str3);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleWithEqual) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuotedMultipleWithEqual", "[app]") {
std::string str, str2, str3, str4;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
app.add_option("-m,--mstr", str3);
app.add_option("-j,--jstr", str4);
app.parse(R"raw(--string="this is my quoted string" -t 'qstring 2' -m=`"quoted string"` --jstr=Unquoted)raw");
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
- EXPECT_EQ(str4, "Unquoted");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
+ CHECK("Unquoted" == str4);
}
-TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleWithEqualAndProgram) {
+TEST_CASE_METHOD(TApp, "OneStringEqualVersionSingleStringQuotedMultipleWithEqualAndProgram", "[app]") {
std::string str, str2, str3, str4;
app.add_option("-s,--string", str);
app.add_option("-t,--tstr", str2);
@@ -410,78 +408,78 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleWithEqualAndProgram)
app.parse(
R"raw(program --string="this is my quoted string" -t 'qstring 2' -m=`"quoted string"` --jstr=Unquoted)raw",
true);
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
- EXPECT_EQ(str4, "Unquoted");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
+ CHECK("Unquoted" == str4);
}
-TEST_F(TApp, OneStringFlagLike) {
+TEST_CASE_METHOD(TApp, "OneStringFlagLike", "[app]") {
std::string str{"something"};
app.add_option("-s,--string", str)->expected(0, 1);
args = {"--string"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_TRUE(str.empty());
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK(str.empty());
}
-TEST_F(TApp, OneIntFlagLike) {
+TEST_CASE_METHOD(TApp, "OneIntFlagLike", "[app]") {
int val{0};
auto opt = app.add_option("-i", val)->expected(0, 1);
args = {"-i"};
run();
- EXPECT_EQ(1u, app.count("-i"));
+ CHECK(app.count("-i") == 1u);
opt->default_str("7");
run();
- EXPECT_EQ(val, 7);
+ CHECK(7 == val);
opt->default_val(9);
run();
- EXPECT_EQ(val, 9);
+ CHECK(9 == val);
}
-TEST_F(TApp, TogetherInt) {
+TEST_CASE_METHOD(TApp, "TogetherInt", "[app]") {
int i{0};
app.add_option("-i,--int", i);
args = {"-i4"};
run();
- EXPECT_EQ(1u, app.count("--int"));
- EXPECT_EQ(1u, app.count("-i"));
- EXPECT_EQ(i, 4);
- EXPECT_EQ(app["-i"]->as<std::string>(), "4");
- EXPECT_EQ(app["--int"]->as<double>(), 4.0);
+ CHECK(app.count("--int") == 1u);
+ CHECK(app.count("-i") == 1u);
+ CHECK(4 == i);
+ CHECK("4" == app["-i"]->as<std::string>());
+ CHECK(4.0 == app["--int"]->as<double>());
}
-TEST_F(TApp, SepInt) {
+TEST_CASE_METHOD(TApp, "SepInt", "[app]") {
int i{0};
app.add_option("-i,--int", i);
args = {"-i", "4"};
run();
- EXPECT_EQ(1u, app.count("--int"));
- EXPECT_EQ(1u, app.count("-i"));
- EXPECT_EQ(i, 4);
+ CHECK(app.count("--int") == 1u);
+ CHECK(app.count("-i") == 1u);
+ CHECK(4 == i);
}
-TEST_F(TApp, DefaultStringAgain) {
+TEST_CASE_METHOD(TApp, "DefaultStringAgain", "[app]") {
std::string str = "previous";
app.add_option("-s,--string", str);
run();
- EXPECT_EQ(0u, app.count("-s"));
- EXPECT_EQ(0u, app.count("--string"));
- EXPECT_EQ(str, "previous");
+ CHECK(app.count("-s") == 0u);
+ CHECK(app.count("--string") == 0u);
+ CHECK("previous" == str);
}
-TEST_F(TApp, DefaultStringAgainEmpty) {
+TEST_CASE_METHOD(TApp, "DefaultStringAgainEmpty", "[app]") {
std::string str = "previous";
app.add_option("-s,--string", str);
app.parse(" ");
- EXPECT_EQ(0u, app.count("-s"));
- EXPECT_EQ(0u, app.count("--string"));
- EXPECT_EQ(str, "previous");
+ CHECK(app.count("-s") == 0u);
+ CHECK(app.count("--string") == 0u);
+ CHECK("previous" == str);
}
-TEST_F(TApp, DualOptions) {
+TEST_CASE_METHOD(TApp, "DualOptions", "[app]") {
std::string str = "previous";
std::vector<std::string> vstr = {"previous"};
@@ -491,13 +489,13 @@ TEST_F(TApp, DualOptions) {
args = {"--vector=one", "--vector=two"};
run();
- EXPECT_EQ(ans, vstr);
+ CHECK(vstr == ans);
args = {"--string=one", "--string=two"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, LotsOfFlags) {
+TEST_CASE_METHOD(TApp, "LotsOfFlags", "[app]") {
app.add_flag("-a");
app.add_flag("-A");
@@ -505,66 +503,66 @@ TEST_F(TApp, LotsOfFlags) {
args = {"-a", "-b", "-aA"};
run();
- EXPECT_EQ(2u, app.count("-a"));
- EXPECT_EQ(1u, app.count("-b"));
- EXPECT_EQ(1u, app.count("-A"));
- EXPECT_EQ(app.count_all(), 4u);
+ CHECK(app.count("-a") == 2u);
+ CHECK(app.count("-b") == 1u);
+ CHECK(app.count("-A") == 1u);
+ CHECK(4u == app.count_all());
}
-TEST_F(TApp, NumberFlags) {
+TEST_CASE_METHOD(TApp, "NumberFlags", "[app]") {
int val{0};
app.add_flag("-1{1},-2{2},-3{3},-4{4},-5{5},-6{6}, -7{7}, -8{8}, -9{9}", val);
args = {"-7"};
run();
- EXPECT_EQ(1u, app.count("-1"));
- EXPECT_EQ(val, 7);
+ CHECK(app.count("-1") == 1u);
+ CHECK(7 == val);
}
-TEST_F(TApp, DisableFlagOverrideTest) {
+TEST_CASE_METHOD(TApp, "DisableFlagOverrideTest", "[app]") {
int val{0};
auto opt = app.add_flag("--1{1},--2{2},--3{3},--4{4},--5{5},--6{6}, --7{7}, --8{8}, --9{9}", val);
- EXPECT_FALSE(opt->get_disable_flag_override());
+ CHECK(!opt->get_disable_flag_override());
opt->disable_flag_override();
args = {"--7=5"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
- EXPECT_TRUE(opt->get_disable_flag_override());
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
+ CHECK(opt->get_disable_flag_override());
opt->disable_flag_override(false);
- EXPECT_FALSE(opt->get_disable_flag_override());
- EXPECT_NO_THROW(run());
- EXPECT_EQ(val, 5);
+ CHECK(!opt->get_disable_flag_override());
+ CHECK_NOTHROW(run());
+ CHECK(5 == val);
opt->disable_flag_override();
args = {"--7=7"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(TApp, LotsOfFlagsSingleString) {
+TEST_CASE_METHOD(TApp, "LotsOfFlagsSingleString", "[app]") {
app.add_flag("-a");
app.add_flag("-A");
app.add_flag("-b");
app.parse("-a -b -aA");
- EXPECT_EQ(2u, app.count("-a"));
- EXPECT_EQ(1u, app.count("-b"));
- EXPECT_EQ(1u, app.count("-A"));
+ CHECK(app.count("-a") == 2u);
+ CHECK(app.count("-b") == 1u);
+ CHECK(app.count("-A") == 1u);
}
-TEST_F(TApp, LotsOfFlagsSingleStringExtraSpace) {
+TEST_CASE_METHOD(TApp, "LotsOfFlagsSingleStringExtraSpace", "[app]") {
app.add_flag("-a");
app.add_flag("-A");
app.add_flag("-b");
app.parse(" -a -b -aA ");
- EXPECT_EQ(2u, app.count("-a"));
- EXPECT_EQ(1u, app.count("-b"));
- EXPECT_EQ(1u, app.count("-A"));
+ CHECK(app.count("-a") == 2u);
+ CHECK(app.count("-b") == 1u);
+ CHECK(app.count("-A") == 1u);
}
-TEST_F(TApp, SingleArgVector) {
+TEST_CASE_METHOD(TApp, "SingleArgVector", "[app]") {
std::vector<std::string> channels;
std::vector<std::string> iargs;
@@ -574,65 +572,65 @@ TEST_F(TApp, SingleArgVector) {
app.add_option("-p", path);
app.parse("-c t1 -c t2 -c t3 a1 a2 a3 a4 -p happy");
- EXPECT_EQ(3u, channels.size());
- EXPECT_EQ(4u, iargs.size());
- EXPECT_EQ(path, "happy");
+ CHECK(channels.size() == 3u);
+ CHECK(iargs.size() == 4u);
+ CHECK("happy" == path);
app.parse("-c t1 a1 -c t2 -c t3 a2 a3 a4 -p happy");
- EXPECT_EQ(3u, channels.size());
- EXPECT_EQ(4u, iargs.size());
- EXPECT_EQ(path, "happy");
+ CHECK(channels.size() == 3u);
+ CHECK(iargs.size() == 4u);
+ CHECK("happy" == path);
}
-TEST_F(TApp, FlagLikeOption) {
+TEST_CASE_METHOD(TApp, "FlagLikeOption", "[app]") {
bool val{false};
auto opt = app.add_option("--flag", val)->type_size(0)->default_str("true");
args = {"--flag"};
run();
- EXPECT_EQ(1u, app.count("--flag"));
- EXPECT_TRUE(val);
+ CHECK(app.count("--flag") == 1u);
+ CHECK(val);
val = false;
opt->type_size(0, 0); // should be the same as above
- EXPECT_EQ(opt->get_type_size_min(), 0);
- EXPECT_EQ(opt->get_type_size_max(), 0);
+ CHECK(0 == opt->get_type_size_min());
+ CHECK(0 == opt->get_type_size_max());
run();
- EXPECT_EQ(1u, app.count("--flag"));
- EXPECT_TRUE(val);
+ CHECK(app.count("--flag") == 1u);
+ CHECK(val);
}
-TEST_F(TApp, FlagLikeIntOption) {
+TEST_CASE_METHOD(TApp, "FlagLikeIntOption", "[app]") {
int val{-47};
auto opt = app.add_option("--flag", val)->expected(0, 1);
// normally some default value should be set, but this test is for some paths in the validators checks to skip
// validation on empty string if nothing is expected
opt->check(CLI::PositiveNumber);
args = {"--flag"};
- EXPECT_TRUE(opt->as<std::string>().empty());
+ CHECK(opt->as<std::string>().empty());
run();
- EXPECT_EQ(1u, app.count("--flag"));
- EXPECT_NE(val, -47);
+ CHECK(app.count("--flag") == 1u);
+ CHECK(-47 != val);
args = {"--flag", "12"};
run();
- EXPECT_EQ(val, 12);
+ CHECK(12 == val);
args.clear();
run();
- EXPECT_TRUE(opt->as<std::string>().empty());
+ CHECK(opt->as<std::string>().empty());
}
-TEST_F(TApp, BoolOnlyFlag) {
+TEST_CASE_METHOD(TApp, "BoolOnlyFlag", "[app]") {
bool bflag{false};
app.add_flag("-b", bflag)->multi_option_policy(CLI::MultiOptionPolicy::Throw);
args = {"-b"};
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(bflag);
+ REQUIRE_NOTHROW(run());
+ CHECK(bflag);
args = {"-b", "-b"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, ShortOpts) {
+TEST_CASE_METHOD(TApp, "ShortOpts", "[app]") {
std::uint64_t funnyint{0};
std::string someopt;
@@ -645,14 +643,14 @@ TEST_F(TApp, ShortOpts) {
run();
- EXPECT_EQ(2u, app.count("-z"));
- EXPECT_EQ(1u, app.count("-y"));
- EXPECT_EQ(std::uint64_t{2}, funnyint);
- EXPECT_EQ("zyz", someopt);
- EXPECT_EQ(app.count_all(), 3u);
+ CHECK(app.count("-z") == 2u);
+ CHECK(app.count("-y") == 1u);
+ CHECK(funnyint == std::uint64_t{2});
+ CHECK(someopt == "zyz");
+ CHECK(3u == app.count_all());
}
-TEST_F(TApp, TwoParamTemplateOpts) {
+TEST_CASE_METHOD(TApp, "TwoParamTemplateOpts", "[app]") {
double funnyint{0.0};
auto opt = app.add_option<double, unsigned int>("-y", funnyint);
@@ -661,19 +659,19 @@ TEST_F(TApp, TwoParamTemplateOpts) {
run();
- EXPECT_EQ(32.0, funnyint);
+ CHECK(funnyint == 32.0);
args = {"-y", "32.3"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
args = {"-y", "-19"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
opt->capture_default_str();
- EXPECT_TRUE(opt->get_default_str().empty());
+ CHECK(opt->get_default_str().empty());
}
-TEST_F(TApp, DefaultOpts) {
+TEST_CASE_METHOD(TApp, "DefaultOpts", "[app]") {
int i{3};
std::string s = "HI";
@@ -685,13 +683,13 @@ TEST_F(TApp, DefaultOpts) {
run();
- EXPECT_EQ(1u, app.count("i"));
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(2, i);
- EXPECT_EQ("9", s);
+ CHECK(app.count("i") == 1u);
+ CHECK(app.count("-s") == 1u);
+ CHECK(i == 2);
+ CHECK(s == "9");
}
-TEST_F(TApp, TakeLastOpt) {
+TEST_CASE_METHOD(TApp, "TakeLastOpt", "[app]") {
std::string str;
app.add_option("--str", str)->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
@@ -700,10 +698,10 @@ TEST_F(TApp, TakeLastOpt) {
run();
- EXPECT_EQ(str, "two");
+ CHECK("two" == str);
}
-TEST_F(TApp, TakeLastOpt2) {
+TEST_CASE_METHOD(TApp, "TakeLastOpt2", "[app]") {
std::string str;
app.add_option("--str", str)->take_last();
@@ -712,10 +710,10 @@ TEST_F(TApp, TakeLastOpt2) {
run();
- EXPECT_EQ(str, "two");
+ CHECK("two" == str);
}
-TEST_F(TApp, TakeFirstOpt) {
+TEST_CASE_METHOD(TApp, "TakeFirstOpt", "[app]") {
std::string str;
app.add_option("--str", str)->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst);
@@ -724,10 +722,10 @@ TEST_F(TApp, TakeFirstOpt) {
run();
- EXPECT_EQ(str, "one");
+ CHECK("one" == str);
}
-TEST_F(TApp, TakeFirstOpt2) {
+TEST_CASE_METHOD(TApp, "TakeFirstOpt2", "[app]") {
std::string str;
app.add_option("--str", str)->take_first();
@@ -736,10 +734,10 @@ TEST_F(TApp, TakeFirstOpt2) {
run();
- EXPECT_EQ(str, "one");
+ CHECK("one" == str);
}
-TEST_F(TApp, JoinOpt) {
+TEST_CASE_METHOD(TApp, "JoinOpt", "[app]") {
std::string str;
app.add_option("--str", str)->multi_option_policy(CLI::MultiOptionPolicy::Join);
@@ -748,10 +746,10 @@ TEST_F(TApp, JoinOpt) {
run();
- EXPECT_EQ(str, "one\ntwo");
+ CHECK("one\ntwo" == str);
}
-TEST_F(TApp, JoinOpt2) {
+TEST_CASE_METHOD(TApp, "JoinOpt2", "[app]") {
std::string str;
app.add_option("--str", str)->join();
@@ -760,10 +758,10 @@ TEST_F(TApp, JoinOpt2) {
run();
- EXPECT_EQ(str, "one\ntwo");
+ CHECK("one\ntwo" == str);
}
-TEST_F(TApp, TakeLastOptMulti) {
+TEST_CASE_METHOD(TApp, "TakeLastOptMulti", "[app]") {
std::vector<int> vals;
app.add_option("--long", vals)->expected(2)->take_last();
@@ -771,10 +769,10 @@ TEST_F(TApp, TakeLastOptMulti) {
run();
- EXPECT_EQ(vals, std::vector<int>({2, 3}));
+ CHECK(std::vector<int>({2, 3}) == vals);
}
-TEST_F(TApp, TakeLastOptMulti_alternative_path) {
+TEST_CASE_METHOD(TApp, "TakeLastOptMulti_alternative_path", "[app]") {
std::vector<int> vals;
app.add_option("--long", vals)->expected(2, -1)->take_last();
@@ -782,10 +780,10 @@ TEST_F(TApp, TakeLastOptMulti_alternative_path) {
run();
- EXPECT_EQ(vals, std::vector<int>({2, 3}));
+ CHECK(std::vector<int>({2, 3}) == vals);
}
-TEST_F(TApp, TakeLastOptMultiCheck) {
+TEST_CASE_METHOD(TApp, "TakeLastOptMultiCheck", "[app]") {
std::vector<int> vals;
auto opt = app.add_option("--long", vals)->expected(-2)->take_last();
@@ -793,12 +791,12 @@ TEST_F(TApp, TakeLastOptMultiCheck) {
opt->check((!CLI::PositiveNumber).application_index(1));
args = {"--long", "-1", "2", "-3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
- EXPECT_EQ(vals, std::vector<int>({2, -3}));
+ CHECK(std::vector<int>({2, -3}) == vals);
}
-TEST_F(TApp, TakeFirstOptMulti) {
+TEST_CASE_METHOD(TApp, "TakeFirstOptMulti", "[app]") {
std::vector<int> vals;
app.add_option("--long", vals)->expected(2)->take_first();
@@ -806,10 +804,10 @@ TEST_F(TApp, TakeFirstOptMulti) {
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
}
-TEST_F(TApp, ComplexOptMulti) {
+TEST_CASE_METHOD(TApp, "ComplexOptMulti", "[app]") {
std::complex<double> val;
app.add_complex("--long", val)->take_first()->allow_extra_args();
@@ -817,35 +815,35 @@ TEST_F(TApp, ComplexOptMulti) {
run();
- EXPECT_DOUBLE_EQ(val.real(), 1);
- EXPECT_DOUBLE_EQ(val.imag(), 2);
+ CHECK(1 == Approx(val.real()));
+ CHECK(2 == Approx(val.imag()));
}
-TEST_F(TApp, MissingValueNonRequiredOpt) {
+TEST_CASE_METHOD(TApp, "MissingValueNonRequiredOpt", "[app]") {
int count{0};
app.add_option("-c,--count", count);
args = {"-c"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"--count"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, MissingValueMoreThan) {
+TEST_CASE_METHOD(TApp, "MissingValueMoreThan", "[app]") {
std::vector<int> vals1;
std::vector<int> vals2;
app.add_option("-v", vals1)->expected(-2);
app.add_option("--vals", vals2)->expected(-2);
args = {"-v", "2"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"--vals", "4"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, NoMissingValueMoreThan) {
+TEST_CASE_METHOD(TApp, "NoMissingValueMoreThan", "[app]") {
std::vector<int> vals1;
std::vector<int> vals2;
app.add_option("-v", vals1)->expected(-2);
@@ -853,104 +851,104 @@ TEST_F(TApp, NoMissingValueMoreThan) {
args = {"-v", "2", "3", "4"};
run();
- EXPECT_EQ(vals1, std::vector<int>({2, 3, 4}));
+ CHECK(std::vector<int>({2, 3, 4}) == vals1);
args = {"--vals", "2", "3", "4"};
run();
- EXPECT_EQ(vals2, std::vector<int>({2, 3, 4}));
+ CHECK(std::vector<int>({2, 3, 4}) == vals2);
}
-TEST_F(TApp, NotRequiredOptsSingle) {
+TEST_CASE_METHOD(TApp, "NotRequiredOptsSingle", "[app]") {
std::string str;
app.add_option("--str", str);
args = {"--str"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, NotRequiredOptsSingleShort) {
+TEST_CASE_METHOD(TApp, "NotRequiredOptsSingleShort", "[app]") {
std::string str;
app.add_option("-s", str);
args = {"-s"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, RequiredOptsSingle) {
+TEST_CASE_METHOD(TApp, "RequiredOptsSingle", "[app]") {
std::string str;
app.add_option("--str", str)->required();
args = {"--str"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, RequiredOptsSingleShort) {
+TEST_CASE_METHOD(TApp, "RequiredOptsSingleShort", "[app]") {
std::string str;
app.add_option("-s", str)->required();
args = {"-s"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, RequiredOptsDouble) {
+TEST_CASE_METHOD(TApp, "RequiredOptsDouble", "[app]") {
std::vector<std::string> strs;
app.add_option("--str", strs)->required()->expected(2);
args = {"--str", "one"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"--str", "one", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
}
-TEST_F(TApp, RequiredOptsDoubleShort) {
+TEST_CASE_METHOD(TApp, "RequiredOptsDoubleShort", "[app]") {
std::vector<std::string> strs;
app.add_option("-s", strs)->required()->expected(2);
args = {"-s", "one"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"-s", "one", "-s", "one", "-s", "one"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, RequiredOptsDoubleNeg) {
+TEST_CASE_METHOD(TApp, "RequiredOptsDoubleNeg", "[app]") {
std::vector<std::string> strs;
app.add_option("-s", strs)->required()->expected(-2);
args = {"-s", "one"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"-s", "one", "two", "-s", "three"};
- ASSERT_NO_THROW(run());
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two", "three"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(std::vector<std::string>({"one", "two", "three"}) == strs);
args = {"-s", "one", "two"};
- ASSERT_NO_THROW(run());
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
}
// This makes sure unlimited option priority is
// correct for space vs. no space #90
-TEST_F(TApp, PositionalNoSpace) {
+TEST_CASE_METHOD(TApp, "PositionalNoSpace", "[app]") {
std::vector<std::string> options;
std::string foo, bar;
@@ -961,37 +959,37 @@ TEST_F(TApp, PositionalNoSpace) {
args = {"-O", "Test", "param1", "param2"};
run();
- EXPECT_EQ(options.size(), 1u);
- EXPECT_EQ(options.at(0), "Test");
+ CHECK(1u == options.size());
+ CHECK("Test" == options.at(0));
args = {"-OTest", "param1", "param2"};
run();
- EXPECT_EQ(options.size(), 1u);
- EXPECT_EQ(options.at(0), "Test");
+ CHECK(1u == options.size());
+ CHECK("Test" == options.at(0));
}
// Tests positionals at end
-TEST_F(TApp, PositionalAtEnd) {
+TEST_CASE_METHOD(TApp, "PositionalAtEnd", "[app]") {
std::string options;
std::string foo;
app.add_option("-O", options);
app.add_option("foo", foo);
app.positionals_at_end();
- EXPECT_TRUE(app.get_positionals_at_end());
+ CHECK(app.get_positionals_at_end());
args = {"-O", "Test", "param1"};
run();
- EXPECT_EQ(options, "Test");
- EXPECT_EQ(foo, "param1");
+ CHECK("Test" == options);
+ CHECK("param1" == foo);
args = {"param2", "-O", "Test"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
// Tests positionals at end
-TEST_F(TApp, RequiredPositionals) {
+TEST_CASE_METHOD(TApp, "RequiredPositionals", "[app]") {
std::vector<std::string> sources;
std::string dest;
app.add_option("src", sources);
@@ -1001,18 +999,18 @@ TEST_F(TApp, RequiredPositionals) {
args = {"1", "2", "3"};
run();
- EXPECT_EQ(sources.size(), 2u);
- EXPECT_EQ(dest, "3");
+ CHECK(2u == sources.size());
+ CHECK("3" == dest);
args = {"a"};
sources.clear();
run();
- EXPECT_EQ(sources.size(), 0u);
- EXPECT_EQ(dest, "a");
+ CHECK(0u == sources.size());
+ CHECK("a" == dest);
}
-TEST_F(TApp, RequiredPositionalVector) {
+TEST_CASE_METHOD(TApp, "RequiredPositionalVector", "[app]") {
std::string d1;
std::string d2;
std::string d3;
@@ -1028,19 +1026,19 @@ TEST_F(TApp, RequiredPositionalVector) {
args = {"1", "2", "3"};
run();
- EXPECT_EQ(sources.size(), 1u);
- EXPECT_EQ(d1, "1");
- EXPECT_EQ(d2, "2");
- EXPECT_TRUE(d3.empty());
+ CHECK(1u == sources.size());
+ CHECK("1" == d1);
+ CHECK("2" == d2);
+ CHECK(d3.empty());
args = {"a"};
sources.clear();
run();
- EXPECT_EQ(sources.size(), 1u);
+ CHECK(1u == sources.size());
}
// Tests positionals at end
-TEST_F(TApp, RequiredPositionalValidation) {
+TEST_CASE_METHOD(TApp, "RequiredPositionalValidation", "[app]") {
std::vector<std::string> sources;
int dest; // required
std::string d2;
@@ -1052,13 +1050,13 @@ TEST_F(TApp, RequiredPositionalValidation) {
args = {"1", "2", "string", "3"};
run();
- EXPECT_EQ(sources.size(), 2u);
- EXPECT_EQ(dest, 3);
- EXPECT_EQ(d2, "string");
+ CHECK(2u == sources.size());
+ CHECK(3 == dest);
+ CHECK("string" == d2);
}
// Tests positionals at end
-TEST_F(TApp, PositionalValidation) {
+TEST_CASE_METHOD(TApp, "PositionalValidation", "[app]") {
std::string options;
std::string foo;
@@ -1069,19 +1067,19 @@ TEST_F(TApp, PositionalValidation) {
args = {"1", "param1"};
run();
- EXPECT_EQ(options, "1");
- EXPECT_EQ(foo, "param1");
+ CHECK("1" == options);
+ CHECK("param1" == foo);
args = {"param1", "1"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
- EXPECT_EQ(options, "1");
- EXPECT_EQ(foo, "param1");
+ CHECK("1" == options);
+ CHECK("param1" == foo);
- EXPECT_NE(app.get_option("bar")->get_validator("valbar"), nullptr);
+ CHECK(nullptr != app.get_option("bar")->get_validator("valbar"));
}
-TEST_F(TApp, PositionalNoSpaceLong) {
+TEST_CASE_METHOD(TApp, "PositionalNoSpaceLong", "[app]") {
std::vector<std::string> options;
std::string foo, bar;
@@ -1092,107 +1090,107 @@ TEST_F(TApp, PositionalNoSpaceLong) {
args = {"--option", "Test", "param1", "param2"};
run();
- EXPECT_EQ(options.size(), 1u);
- EXPECT_EQ(options.at(0), "Test");
+ CHECK(1u == options.size());
+ CHECK("Test" == options.at(0));
args = {"--option=Test", "param1", "param2"};
run();
- EXPECT_EQ(options.size(), 1u);
- EXPECT_EQ(options.at(0), "Test");
+ CHECK(1u == options.size());
+ CHECK("Test" == options.at(0));
}
-TEST_F(TApp, RequiredOptsUnlimited) {
+TEST_CASE_METHOD(TApp, "RequiredOptsUnlimited", "[app]") {
std::vector<std::string> strs;
app.add_option("--str", strs)->required();
args = {"--str"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"--str", "one", "--str", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
args = {"--str", "one", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
// It's better to feed a hungry option than to feed allow_extras
app.allow_extras();
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(app.remaining(), std::vector<std::string>({}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
+ CHECK(std::vector<std::string>({}) == app.remaining());
app.allow_extras(false);
std::vector<std::string> remain;
auto popt = app.add_option("positional", remain);
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(remain, std::vector<std::string>());
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
+ CHECK(std::vector<std::string>() == remain);
args = {"--str", "one", "--", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two"}));
+ CHECK(std::vector<std::string>({"one"}) == strs);
+ CHECK(std::vector<std::string>({"two"}) == remain);
args = {"one", "--str", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"two"}));
- EXPECT_EQ(remain, std::vector<std::string>({"one"}));
+ CHECK(std::vector<std::string>({"two"}) == strs);
+ CHECK(std::vector<std::string>({"one"}) == remain);
args = {"--str", "one", "two"};
popt->required();
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two"}));
+ CHECK(std::vector<std::string>({"one"}) == strs);
+ CHECK(std::vector<std::string>({"two"}) == remain);
}
-TEST_F(TApp, RequiredOptsUnlimitedShort) {
+TEST_CASE_METHOD(TApp, "RequiredOptsUnlimitedShort", "[app]") {
std::vector<std::string> strs;
app.add_option("-s", strs)->required();
args = {"-s"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"-s", "one", "-s", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
args = {"-s", "one", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
// It's better to feed a hungry option than to feed allow_extras
app.allow_extras();
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(app.remaining(), std::vector<std::string>({}));
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
+ CHECK(std::vector<std::string>({}) == app.remaining());
app.allow_extras(false);
std::vector<std::string> remain;
app.add_option("positional", remain);
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(remain, std::vector<std::string>());
+ CHECK(std::vector<std::string>({"one", "two"}) == strs);
+ CHECK(std::vector<std::string>() == remain);
args = {"-s", "one", "--", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two"}));
+ CHECK(std::vector<std::string>({"one"}) == strs);
+ CHECK(std::vector<std::string>({"two"}) == remain);
args = {"one", "-s", "two"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"two"}));
- EXPECT_EQ(remain, std::vector<std::string>({"one"}));
+ CHECK(std::vector<std::string>({"two"}) == strs);
+ CHECK(std::vector<std::string>({"one"}) == remain);
}
-TEST_F(TApp, OptsUnlimitedEnd) {
+TEST_CASE_METHOD(TApp, "OptsUnlimitedEnd", "[app]") {
std::vector<std::string> strs;
app.add_option("-s,--str", strs);
app.allow_extras();
@@ -1201,11 +1199,11 @@ TEST_F(TApp, OptsUnlimitedEnd) {
run();
- EXPECT_EQ(strs, std::vector<std::string>({"two", "three"}));
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"one", "four"}));
+ CHECK(std::vector<std::string>({"two", "three"}) == strs);
+ CHECK(std::vector<std::string>({"one", "four"}) == app.remaining());
}
-TEST_F(TApp, RequireOptPriority) {
+TEST_CASE_METHOD(TApp, "RequireOptPriority", "[app]") {
std::vector<std::string> strs;
app.add_option("--str", strs);
@@ -1215,17 +1213,17 @@ TEST_F(TApp, RequireOptPriority) {
args = {"--str", "one", "two", "three"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two", "three"}));
+ CHECK(std::vector<std::string>({"one"}) == strs);
+ CHECK(std::vector<std::string>({"two", "three"}) == remain);
args = {"two", "three", "--str", "one", "four"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "four"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two", "three"}));
+ CHECK(std::vector<std::string>({"one", "four"}) == strs);
+ CHECK(std::vector<std::string>({"two", "three"}) == remain);
}
-TEST_F(TApp, RequireOptPriorityShort) {
+TEST_CASE_METHOD(TApp, "RequireOptPriorityShort", "[app]") {
std::vector<std::string> strs;
app.add_option("-s", strs)->required();
@@ -1235,53 +1233,53 @@ TEST_F(TApp, RequireOptPriorityShort) {
args = {"-s", "one", "two", "three"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two", "three"}));
+ CHECK(std::vector<std::string>({"one"}) == strs);
+ CHECK(std::vector<std::string>({"two", "three"}) == remain);
args = {"two", "three", "-s", "one", "four"};
run();
- EXPECT_EQ(strs, std::vector<std::string>({"one", "four"}));
- EXPECT_EQ(remain, std::vector<std::string>({"two", "three"}));
+ CHECK(std::vector<std::string>({"one", "four"}) == strs);
+ CHECK(std::vector<std::string>({"two", "three"}) == remain);
}
-TEST_F(TApp, NotRequiredExpectedDouble) {
+TEST_CASE_METHOD(TApp, "NotRequiredExpectedDouble", "[app]") {
std::vector<std::string> strs;
app.add_option("--str", strs)->expected(2);
args = {"--str", "one"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, NotRequiredExpectedDoubleShort) {
+TEST_CASE_METHOD(TApp, "NotRequiredExpectedDoubleShort", "[app]") {
std::vector<std::string> strs;
app.add_option("-s", strs)->expected(2);
args = {"-s", "one"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, RequiredFlags) {
+TEST_CASE_METHOD(TApp, "RequiredFlags", "[app]") {
app.add_flag("-a")->required();
app.add_flag("-b")->mandatory(); // Alternate term
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"-a"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"-b"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"-a", "-b"};
run();
}
-TEST_F(TApp, CallbackFlags) {
+TEST_CASE_METHOD(TApp, "CallbackFlags", "[app]") {
std::int64_t value{0};
@@ -1290,20 +1288,20 @@ TEST_F(TApp, CallbackFlags) {
app.add_flag_function("-v", func);
run();
- EXPECT_EQ(value, 0u);
+ CHECK(0u == value);
args = {"-v"};
run();
- EXPECT_EQ(value, 1u);
+ CHECK(1u == value);
args = {"-vv"};
run();
- EXPECT_EQ(value, 2u);
+ CHECK(2u == value);
- EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
}
-TEST_F(TApp, CallbackFlagsFalse) {
+TEST_CASE_METHOD(TApp, "CallbackFlagsFalse", "[app]") {
std::int64_t value = 0;
auto func = [&value](std::int64_t x) { value = x; };
@@ -1311,28 +1309,28 @@ TEST_F(TApp, CallbackFlagsFalse) {
app.add_flag_function("-v,-f{false},--val,--fval{false}", func);
run();
- EXPECT_EQ(value, 0);
+ CHECK(0 == value);
args = {"-f"};
run();
- EXPECT_EQ(value, -1);
+ CHECK(-1 == value);
args = {"-vfv"};
run();
- EXPECT_EQ(value, 1);
+ CHECK(1 == value);
args = {"--fval"};
run();
- EXPECT_EQ(value, -1);
+ CHECK(-1 == value);
args = {"--fval=2"};
run();
- EXPECT_EQ(value, -2);
+ CHECK(-2 == value);
- EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
}
-TEST_F(TApp, CallbackFlagsFalseShortcut) {
+TEST_CASE_METHOD(TApp, "CallbackFlagsFalseShortcut", "[app]") {
std::int64_t value = 0;
auto func = [&value](std::int64_t x) { value = x; };
@@ -1340,29 +1338,29 @@ TEST_F(TApp, CallbackFlagsFalseShortcut) {
app.add_flag_function("-v,!-f,--val,!--fval", func);
run();
- EXPECT_EQ(value, 0);
+ CHECK(0 == value);
args = {"-f"};
run();
- EXPECT_EQ(value, -1);
+ CHECK(-1 == value);
args = {"-vfv"};
run();
- EXPECT_EQ(value, 1);
+ CHECK(1 == value);
args = {"--fval"};
run();
- EXPECT_EQ(value, -1);
+ CHECK(-1 == value);
args = {"--fval=2"};
run();
- EXPECT_EQ(value, -2);
+ CHECK(-2 == value);
- EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
}
#if __cplusplus >= 201402L || _MSC_VER >= 1900
-TEST_F(TApp, CallbackFlagsAuto) {
+TEST_CASE_METHOD(TApp, "CallbackFlagsAuto", "[app]") {
std::int64_t value{0};
@@ -1371,21 +1369,21 @@ TEST_F(TApp, CallbackFlagsAuto) {
app.add_flag("-v", func);
run();
- EXPECT_EQ(value, 0u);
+ CHECK(0u == value);
args = {"-v"};
run();
- EXPECT_EQ(value, 1u);
+ CHECK(1u == value);
args = {"-vv"};
run();
- EXPECT_EQ(value, 2u);
+ CHECK(2u == value);
- EXPECT_THROW(app.add_flag("hi", func), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag("hi", func), CLI::IncorrectConstruction);
}
#endif
-TEST_F(TApp, Positionals) {
+TEST_CASE_METHOD(TApp, "Positionals", "[app]") {
std::string posit1;
std::string posit2;
@@ -1396,13 +1394,13 @@ TEST_F(TApp, Positionals) {
run();
- EXPECT_EQ(1u, app.count("posit1"));
- EXPECT_EQ(1u, app.count("posit2"));
- EXPECT_EQ("thing1", posit1);
- EXPECT_EQ("thing2", posit2);
+ CHECK(app.count("posit1") == 1u);
+ CHECK(app.count("posit2") == 1u);
+ CHECK(posit1 == "thing1");
+ CHECK(posit2 == "thing2");
}
-TEST_F(TApp, ForcedPositional) {
+TEST_CASE_METHOD(TApp, "ForcedPositional", "[app]") {
std::vector<std::string> posit;
auto one = app.add_flag("--one");
app.add_option("posit", posit);
@@ -1410,18 +1408,18 @@ TEST_F(TApp, ForcedPositional) {
args = {"--one", "two", "three"};
run();
std::vector<std::string> answers1 = {"two", "three"};
- EXPECT_TRUE(one->count());
- EXPECT_EQ(answers1, posit);
+ CHECK(one->count());
+ CHECK(posit == answers1);
args = {"--", "--one", "two", "three"};
std::vector<std::string> answers2 = {"--one", "two", "three"};
run();
- EXPECT_FALSE(one->count());
- EXPECT_EQ(answers2, posit);
+ CHECK(!one->count());
+ CHECK(posit == answers2);
}
-TEST_F(TApp, MixedPositionals) {
+TEST_CASE_METHOD(TApp, "MixedPositionals", "[app]") {
int positional_int{0};
std::string positional_string;
@@ -1432,28 +1430,28 @@ TEST_F(TApp, MixedPositionals) {
run();
- EXPECT_EQ(1u, app.count("posit2"));
- EXPECT_EQ(1u, app.count("--posit1"));
- EXPECT_EQ(7, positional_int);
- EXPECT_EQ("thing2", positional_string);
+ CHECK(app.count("posit2") == 1u);
+ CHECK(app.count("--posit1") == 1u);
+ CHECK(positional_int == 7);
+ CHECK(positional_string == "thing2");
}
-TEST_F(TApp, BigPositional) {
+TEST_CASE_METHOD(TApp, "BigPositional", "[app]") {
std::vector<std::string> vec;
app.add_option("pos", vec);
args = {"one"};
run();
- EXPECT_EQ(args, vec);
+ CHECK(vec == args);
args = {"one", "two"};
run();
- EXPECT_EQ(args, vec);
+ CHECK(vec == args);
}
-TEST_F(TApp, Reset) {
+TEST_CASE_METHOD(TApp, "Reset", "[app]") {
app.add_flag("--simple");
double doub{0.0};
@@ -1463,139 +1461,139 @@ TEST_F(TApp, Reset) {
run();
- EXPECT_EQ(1u, app.count("--simple"));
- EXPECT_EQ(1u, app.count("-d"));
- EXPECT_DOUBLE_EQ(1.2, doub);
+ CHECK(app.count("--simple") == 1u);
+ CHECK(app.count("-d") == 1u);
+ CHECK(doub == Approx(1.2));
app.clear();
- EXPECT_EQ(0u, app.count("--simple"));
- EXPECT_EQ(0u, app.count("-d"));
+ CHECK(app.count("--simple") == 0u);
+ CHECK(app.count("-d") == 0u);
run();
- EXPECT_EQ(1u, app.count("--simple"));
- EXPECT_EQ(1u, app.count("-d"));
- EXPECT_DOUBLE_EQ(1.2, doub);
+ CHECK(app.count("--simple") == 1u);
+ CHECK(app.count("-d") == 1u);
+ CHECK(doub == Approx(1.2));
}
-TEST_F(TApp, RemoveOption) {
+TEST_CASE_METHOD(TApp, "RemoveOption", "[app]") {
app.add_flag("--one");
auto opt = app.add_flag("--two");
- EXPECT_TRUE(app.remove_option(opt));
- EXPECT_FALSE(app.remove_option(opt));
+ CHECK(app.remove_option(opt));
+ CHECK(!app.remove_option(opt));
args = {"--two"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, RemoveNeedsLinks) {
+TEST_CASE_METHOD(TApp, "RemoveNeedsLinks", "[app]") {
auto one = app.add_flag("--one");
auto two = app.add_flag("--two");
two->needs(one);
one->needs(two);
- EXPECT_TRUE(app.remove_option(one));
+ CHECK(app.remove_option(one));
args = {"--two"};
run();
}
-TEST_F(TApp, RemoveExcludesLinks) {
+TEST_CASE_METHOD(TApp, "RemoveExcludesLinks", "[app]") {
auto one = app.add_flag("--one");
auto two = app.add_flag("--two");
two->excludes(one);
one->excludes(two);
- EXPECT_TRUE(app.remove_option(one));
+ CHECK(app.remove_option(one));
args = {"--two"};
run(); // Mostly hoping it does not crash
}
-TEST_F(TApp, FileNotExists) {
+TEST_CASE_METHOD(TApp, "FileNotExists", "[app]") {
std::string myfile{"TestNonFileNotUsed.txt"};
- ASSERT_NO_THROW(CLI::NonexistentPath(myfile));
+ REQUIRE_NOTHROW(CLI::NonexistentPath(myfile));
std::string filename;
auto opt = app.add_option("--file", filename)->check(CLI::NonexistentPath, "path_check");
args = {"--file", myfile};
run();
- EXPECT_EQ(myfile, filename);
+ CHECK(filename == myfile);
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK(ok);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
// deactivate the check, so it should run now
opt->get_validator("path_check")->active(false);
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
std::remove(myfile.c_str());
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK(!CLI::ExistingFile(myfile).empty());
}
-TEST_F(TApp, FileExists) {
+TEST_CASE_METHOD(TApp, "FileExists", "[app]") {
std::string myfile{"TestNonFileNotUsed.txt"};
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK(!CLI::ExistingFile(myfile).empty());
std::string filename = "Failed";
app.add_option("--file", filename)->check(CLI::ExistingFile);
args = {"--file", myfile};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
+ CHECK(ok);
run();
- EXPECT_EQ(myfile, filename);
+ CHECK(filename == myfile);
std::remove(myfile.c_str());
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK(!CLI::ExistingFile(myfile).empty());
}
-TEST_F(TApp, NotFileExists) {
+TEST_CASE_METHOD(TApp, "NotFileExists", "[app]") {
std::string myfile{"TestNonFileNotUsed.txt"};
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK(!CLI::ExistingFile(myfile).empty());
std::string filename = "Failed";
app.add_option("--file", filename)->check(!CLI::ExistingFile);
args = {"--file", myfile};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK(ok);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
std::remove(myfile.c_str());
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK(!CLI::ExistingFile(myfile).empty());
}
-TEST_F(TApp, DefaultedResult) {
+TEST_CASE_METHOD(TApp, "DefaultedResult", "[app]") {
std::string sval = "NA";
int ival{0};
auto opts = app.add_option("--string", sval)->capture_default_str();
auto optv = app.add_option("--val", ival);
args = {};
run();
- EXPECT_EQ(sval, "NA");
+ CHECK("NA" == sval);
std::string nString;
opts->results(nString);
- EXPECT_EQ(nString, "NA");
+ CHECK("NA" == nString);
int newIval;
- // EXPECT_THROW(optv->results(newIval), CLI::ConversionError);
+ // CHECK_THROWS_AS (optv->results(newIval), CLI::ConversionError);
optv->default_str("442");
optv->results(newIval);
- EXPECT_EQ(newIval, 442);
+ CHECK(442 == newIval);
}
-TEST_F(TApp, OriginalOrder) {
+TEST_CASE_METHOD(TApp, "OriginalOrder", "[app]") {
std::vector<int> st1;
CLI::Option *op1 = app.add_option("-a", st1);
std::vector<int> st2;
@@ -1605,13 +1603,13 @@ TEST_F(TApp, OriginalOrder) {
run();
- EXPECT_EQ(st1, std::vector<int>({1, 3, 4}));
- EXPECT_EQ(st2, std::vector<int>({2}));
+ CHECK(std::vector<int>({1, 3, 4}) == st1);
+ CHECK(std::vector<int>({2}) == st2);
- EXPECT_EQ(app.parse_order(), std::vector<CLI::Option *>({op1, op2, op1, op1}));
+ CHECK(std::vector<CLI::Option *>({op1, op2, op1, op1}) == app.parse_order());
}
-TEST_F(TApp, NeedsFlags) {
+TEST_CASE_METHOD(TApp, "NeedsFlags", "[app]") {
CLI::Option *opt = app.add_flag("-s,--string");
app.add_flag("--both")->needs(opt);
@@ -1624,12 +1622,12 @@ TEST_F(TApp, NeedsFlags) {
run();
args = {"--both"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
- EXPECT_NO_THROW(opt->needs(opt));
+ CHECK_NOTHROW(opt->needs(opt));
}
-TEST_F(TApp, ExcludesFlags) {
+TEST_CASE_METHOD(TApp, "ExcludesFlags", "[app]") {
CLI::Option *opt = app.add_flag("-s,--string");
app.add_flag("--nostr")->excludes(opt);
@@ -1642,15 +1640,15 @@ TEST_F(TApp, ExcludesFlags) {
run();
args = {"--nostr", "-s"};
- EXPECT_THROW(run(), CLI::ExcludesError);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
args = {"--string", "--nostr"};
- EXPECT_THROW(run(), CLI::ExcludesError);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
- EXPECT_THROW(opt->excludes(opt), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(opt->excludes(opt), CLI::IncorrectConstruction);
}
-TEST_F(TApp, ExcludesMixedFlags) {
+TEST_CASE_METHOD(TApp, "ExcludesMixedFlags", "[app]") {
CLI::Option *opt1 = app.add_flag("--opt1");
app.add_flag("--opt2");
CLI::Option *opt3 = app.add_flag("--opt3");
@@ -1665,13 +1663,13 @@ TEST_F(TApp, ExcludesMixedFlags) {
run();
args = {"--no", "--opt1"};
- EXPECT_THROW(run(), CLI::ExcludesError);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
args = {"--no", "--opt2"};
- EXPECT_THROW(run(), CLI::ExcludesError);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
}
-TEST_F(TApp, NeedsMultiFlags) {
+TEST_CASE_METHOD(TApp, "NeedsMultiFlags", "[app]") {
CLI::Option *opt1 = app.add_flag("--opt1");
CLI::Option *opt2 = app.add_flag("--opt2");
CLI::Option *opt3 = app.add_flag("--opt3");
@@ -1686,19 +1684,19 @@ TEST_F(TApp, NeedsMultiFlags) {
run();
args = {"--optall"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--optall", "--opt1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--optall", "--opt2", "--opt1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--optall", "--opt1", "--opt2", "--opt3"};
run();
}
-TEST_F(TApp, NeedsMixedFlags) {
+TEST_CASE_METHOD(TApp, "NeedsMixedFlags", "[app]") {
CLI::Option *opt1 = app.add_flag("--opt1");
app.add_flag("--opt2");
app.add_flag("--opt3");
@@ -1713,19 +1711,19 @@ TEST_F(TApp, NeedsMixedFlags) {
run();
args = {"--optall"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--optall", "--opt1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--optall", "--opt2", "--opt1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--optall", "--opt1", "--opt2", "--opt3"};
run();
}
-TEST_F(TApp, NeedsChainedFlags) {
+TEST_CASE_METHOD(TApp, "NeedsChainedFlags", "[app]") {
CLI::Option *opt1 = app.add_flag("--opt1");
CLI::Option *opt2 = app.add_flag("--opt2")->needs(opt1);
app.add_flag("--opt3")->needs(opt2);
@@ -1736,16 +1734,16 @@ TEST_F(TApp, NeedsChainedFlags) {
run();
args = {"--opt2"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--opt3"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--opt3", "--opt2"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--opt3", "--opt1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--opt2", "--opt1"};
run();
@@ -1754,7 +1752,7 @@ TEST_F(TApp, NeedsChainedFlags) {
run();
}
-TEST_F(TApp, Env) {
+TEST_CASE_METHOD(TApp, "Env", "[app]") {
put_env("CLI11_TEST_ENV_TMP", "2");
@@ -1763,18 +1761,18 @@ TEST_F(TApp, Env) {
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(1u, vopt->count());
+ CHECK(val == 2);
+ CHECK(vopt->count() == 1u);
vopt->required();
run();
unset_env("CLI11_TEST_ENV_TMP");
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
// curiously check if an environmental only option works
-TEST_F(TApp, EnvOnly) {
+TEST_CASE_METHOD(TApp, "EnvOnly", "[app]") {
put_env("CLI11_TEST_ENV_TMP", "2");
@@ -1783,25 +1781,25 @@ TEST_F(TApp, EnvOnly) {
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(1u, vopt->count());
+ CHECK(val == 2);
+ CHECK(vopt->count() == 1u);
vopt->required();
run();
unset_env("CLI11_TEST_ENV_TMP");
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(TApp, RangeInt) {
+TEST_CASE_METHOD(TApp, "RangeInt", "[app]") {
int x{0};
app.add_option("--one", x)->check(CLI::Range(3, 6));
args = {"--one=1"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--one=7"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--one=3"};
run();
@@ -1813,17 +1811,17 @@ TEST_F(TApp, RangeInt) {
run();
}
-TEST_F(TApp, RangeDouble) {
+TEST_CASE_METHOD(TApp, "RangeDouble", "[app]") {
double x{0.0};
/// Note that this must be a double in Range, too
app.add_option("--one", x)->check(CLI::Range(3.0, 6.0));
args = {"--one=1"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--one=7"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--one=3"};
run();
@@ -1835,26 +1833,26 @@ TEST_F(TApp, RangeDouble) {
run();
}
-TEST_F(TApp, typeCheck) {
+TEST_CASE_METHOD(TApp, "typeCheck", "[app]") {
/// Note that this must be a double in Range, too
app.add_option("--one")->check(CLI::TypeValidator<unsigned int>());
args = {"--one=1"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"--one=-7"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--one=error"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--one=4.568"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
// Check to make sure programmatic access to left over is available
-TEST_F(TApp, AllowExtras) {
+TEST_CASE_METHOD(TApp, "AllowExtras", "[app]") {
app.allow_extras();
@@ -1863,32 +1861,32 @@ TEST_F(TApp, AllowExtras) {
args = {"-x", "-f"};
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(val);
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"-x"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(val);
+ CHECK(std::vector<std::string>({"-x"}) == app.remaining());
}
-TEST_F(TApp, AllowExtrasOrder) {
+TEST_CASE_METHOD(TApp, "AllowExtrasOrder", "[app]") {
app.allow_extras();
args = {"-x", "-f"};
- ASSERT_NO_THROW(run());
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"-x", "-f"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(std::vector<std::string>({"-x", "-f"}) == app.remaining());
std::vector<std::string> left_over = app.remaining();
app.parse(left_over);
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"-f", "-x"}));
- EXPECT_EQ(app.remaining_for_passthrough(), left_over);
+ CHECK(std::vector<std::string>({"-f", "-x"}) == app.remaining());
+ CHECK(left_over == app.remaining_for_passthrough());
}
-TEST_F(TApp, AllowExtrasCascade) {
+TEST_CASE_METHOD(TApp, "AllowExtrasCascade", "[app]") {
app.allow_extras();
args = {"-x", "45", "-f", "27"};
- ASSERT_NO_THROW(run());
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"-x", "45", "-f", "27"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(std::vector<std::string>({"-x", "45", "-f", "27"}) == app.remaining());
std::vector<std::string> left_over = app.remaining_for_passthrough();
@@ -1899,23 +1897,23 @@ TEST_F(TApp, AllowExtrasCascade) {
capp.add_option("-f", v2);
capp.parse(left_over);
- EXPECT_EQ(v1, 45);
- EXPECT_EQ(v2, 27);
+ CHECK(45 == v1);
+ CHECK(27 == v2);
}
// makes sure the error throws on the rValue version of the parse
-TEST_F(TApp, ExtrasErrorRvalueParse) {
+TEST_CASE_METHOD(TApp, "ExtrasErrorRvalueParse", "[app]") {
args = {"-x", "45", "-f", "27"};
- EXPECT_THROW(app.parse(std::vector<std::string>({"-x", "45", "-f", "27"})), CLI::ExtrasError);
+ CHECK_THROWS_AS(app.parse(std::vector<std::string>({"-x", "45", "-f", "27"})), CLI::ExtrasError);
}
-TEST_F(TApp, AllowExtrasCascadeDirect) {
+TEST_CASE_METHOD(TApp, "AllowExtrasCascadeDirect", "[app]") {
app.allow_extras();
args = {"-x", "45", "-f", "27"};
- ASSERT_NO_THROW(run());
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"-x", "45", "-f", "27"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(std::vector<std::string>({"-x", "45", "-f", "27"}) == app.remaining());
CLI::App capp{"cascade_program"};
int v1{0};
@@ -1924,11 +1922,11 @@ TEST_F(TApp, AllowExtrasCascadeDirect) {
capp.add_option("-f", v2);
capp.parse(app.remaining_for_passthrough());
- EXPECT_EQ(v1, 45);
- EXPECT_EQ(v2, 27);
+ CHECK(45 == v1);
+ CHECK(27 == v2);
}
-TEST_F(TApp, AllowExtrasArgModify) {
+TEST_CASE_METHOD(TApp, "AllowExtrasArgModify", "[app]") {
int v1{0};
int v2{0};
@@ -1937,88 +1935,89 @@ TEST_F(TApp, AllowExtrasArgModify) {
args = {"27", "-f", "45", "-x"};
auto cargs = args;
app.parse(args);
- EXPECT_EQ(args, std::vector<std::string>({"45", "-x"}));
+ CHECK(std::vector<std::string>({"45", "-x"}) == args);
CLI::App capp{"cascade_program"};
capp.add_option("-x", v1);
capp.parse(args);
- EXPECT_EQ(v1, 45);
- EXPECT_EQ(v2, 27);
+ CHECK(45 == v1);
+ CHECK(27 == v2);
}
// Test horrible error
-TEST_F(TApp, CheckShortFail) {
+TEST_CASE_METHOD(TApp, "CheckShortFail", "[app]") {
args = {"--two"};
- EXPECT_THROW(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::SHORT), CLI::HorribleError);
+ CHECK_THROWS_AS(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::SHORT), CLI::HorribleError);
}
// Test horrible error
-TEST_F(TApp, CheckLongFail) {
+TEST_CASE_METHOD(TApp, "CheckLongFail", "[app]") {
args = {"-t"};
- EXPECT_THROW(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::LONG), CLI::HorribleError);
+ CHECK_THROWS_AS(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::LONG), CLI::HorribleError);
}
// Test horrible error
-TEST_F(TApp, CheckWindowsFail) {
+TEST_CASE_METHOD(TApp, "CheckWindowsFail", "[app]") {
args = {"-t"};
- EXPECT_THROW(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::WINDOWS), CLI::HorribleError);
+ CHECK_THROWS_AS(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::WINDOWS_STYLE),
+ CLI::HorribleError);
}
// Test horrible error
-TEST_F(TApp, CheckOtherFail) {
+TEST_CASE_METHOD(TApp, "CheckOtherFail", "[app]") {
args = {"-t"};
- EXPECT_THROW(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::NONE), CLI::HorribleError);
+ CHECK_THROWS_AS(CLI::detail::AppFriend::parse_arg(&app, args, CLI::detail::Classifier::NONE), CLI::HorribleError);
}
// Test horrible error
-TEST_F(TApp, CheckSubcomFail) {
+TEST_CASE_METHOD(TApp, "CheckSubcomFail", "[app]") {
args = {"subcom"};
- EXPECT_THROW(CLI::detail::AppFriend::parse_subcommand(&app, args), CLI::HorribleError);
+ CHECK_THROWS_AS(CLI::detail::AppFriend::parse_subcommand(&app, args), CLI::HorribleError);
}
-TEST_F(TApp, FallthroughParentFail) {
- EXPECT_THROW(CLI::detail::AppFriend::get_fallthrough_parent(&app), CLI::HorribleError);
+TEST_CASE_METHOD(TApp, "FallthroughParentFail", "[app]") {
+ CHECK_THROWS_AS(CLI::detail::AppFriend::get_fallthrough_parent(&app), CLI::HorribleError);
}
-TEST_F(TApp, FallthroughParents) {
+TEST_CASE_METHOD(TApp, "FallthroughParents", "[app]") {
auto sub = app.add_subcommand("test");
- EXPECT_EQ(CLI::detail::AppFriend::get_fallthrough_parent(sub), &app);
+ CHECK(&app == CLI::detail::AppFriend::get_fallthrough_parent(sub));
auto ssub = sub->add_subcommand("sub2");
- EXPECT_EQ(CLI::detail::AppFriend::get_fallthrough_parent(ssub), sub);
+ CHECK(sub == CLI::detail::AppFriend::get_fallthrough_parent(ssub));
auto og1 = app.add_option_group("g1");
auto og2 = og1->add_option_group("g2");
auto og3 = og2->add_option_group("g3");
- EXPECT_EQ(CLI::detail::AppFriend::get_fallthrough_parent(og3), &app);
+ CHECK(&app == CLI::detail::AppFriend::get_fallthrough_parent(og3));
auto ogb1 = sub->add_option_group("g1");
auto ogb2 = ogb1->add_option_group("g2");
auto ogb3 = ogb2->add_option_group("g3");
- EXPECT_EQ(CLI::detail::AppFriend::get_fallthrough_parent(ogb3), sub);
+ CHECK(sub == CLI::detail::AppFriend::get_fallthrough_parent(ogb3));
ogb2->name("groupb");
- EXPECT_EQ(CLI::detail::AppFriend::get_fallthrough_parent(ogb3), ogb2);
+ CHECK(ogb2 == CLI::detail::AppFriend::get_fallthrough_parent(ogb3));
}
-TEST_F(TApp, OptionWithDefaults) {
+TEST_CASE_METHOD(TApp, "OptionWithDefaults", "[app]") {
int someint{2};
app.add_option("-a", someint)->capture_default_str();
args = {"-a1", "-a2"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
// Added to test ->transform
-TEST_F(TApp, OrderedModifyingTransforms) {
+TEST_CASE_METHOD(TApp, "OrderedModifyingTransforms", "[app]") {
std::vector<std::string> val;
auto m = app.add_option("-m", val);
m->transform([](std::string x) { return x + "1"; });
@@ -2028,29 +2027,29 @@ TEST_F(TApp, OrderedModifyingTransforms) {
run();
- EXPECT_EQ(val, std::vector<std::string>({"one21", "two21"}));
+ CHECK(std::vector<std::string>({"one21", "two21"}) == val);
}
-TEST_F(TApp, ThrowingTransform) {
+TEST_CASE_METHOD(TApp, "ThrowingTransform", "[app]") {
std::string val;
auto m = app.add_option("-m,--mess", val);
m->transform([](std::string) -> std::string { throw CLI::ValidationError("My Message"); });
- ASSERT_NO_THROW(run());
+ REQUIRE_NOTHROW(run());
args = {"-mone"};
- ASSERT_THROW(run(), CLI::ValidationError);
+ REQUIRE_THROWS_AS(run(), CLI::ValidationError);
try {
run();
} catch(const CLI::ValidationError &e) {
- EXPECT_EQ(e.what(), std::string("--mess: My Message"));
+ CHECK(std::string("--mess: My Message") == e.what());
}
}
// This was added to make running a simple function on each item easier
-TEST_F(TApp, EachItem) {
+TEST_CASE_METHOD(TApp, "EachItem", "[app]") {
std::vector<std::string> results;
std::vector<std::string> dummy;
@@ -2063,35 +2062,35 @@ TEST_F(TApp, EachItem) {
run();
- EXPECT_EQ(results, dummy);
+ CHECK(dummy == results);
}
// #128
-TEST_F(TApp, RepeatingMultiArgumentOptions) {
+TEST_CASE_METHOD(TApp, "RepeatingMultiArgumentOptions", "[app]") {
std::vector<std::string> entries;
app.add_option("--entry", entries, "set a key and value")->type_name("KEY VALUE")->type_size(-2);
args = {"--entry", "key1", "value1", "--entry", "key2", "value2"};
- ASSERT_NO_THROW(run());
- EXPECT_EQ(entries, std::vector<std::string>({"key1", "value1", "key2", "value2"}));
+ REQUIRE_NOTHROW(run());
+ CHECK(std::vector<std::string>({"key1", "value1", "key2", "value2"}) == entries);
args.pop_back();
- ASSERT_THROW(run(), CLI::ArgumentMismatch);
+ REQUIRE_THROWS_AS(run(), CLI::ArgumentMismatch);
}
// #122
-TEST_F(TApp, EmptyOptionEach) {
+TEST_CASE_METHOD(TApp, "EmptyOptionEach", "[app]") {
std::string q;
app.add_option("--each")->each([&q](std::string s) { q = s; });
args = {"--each", "that"};
run();
- EXPECT_EQ(q, "that");
+ CHECK("that" == q);
}
// #122
-TEST_F(TApp, EmptyOptionFail) {
+TEST_CASE_METHOD(TApp, "EmptyOptionFail", "[app]") {
std::string q;
app.add_option("--each");
@@ -2099,116 +2098,116 @@ TEST_F(TApp, EmptyOptionFail) {
run();
}
-TEST_F(TApp, BeforeRequirements) {
+TEST_CASE_METHOD(TApp, "BeforeRequirements", "[app]") {
app.add_flag_function("-a", [](std::int64_t) { throw CLI::Success(); });
app.add_flag_function("-b", [](std::int64_t) { throw CLI::CallForHelp(); });
args = {"extra"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"-a", "extra"};
- EXPECT_THROW(run(), CLI::Success);
+ CHECK_THROWS_AS(run(), CLI::Success);
args = {"-b", "extra"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
// These run in definition order.
args = {"-a", "-b", "extra"};
- EXPECT_THROW(run(), CLI::Success);
+ CHECK_THROWS_AS(run(), CLI::Success);
// Currently, the original order is not preserved when calling callbacks
// args = {"-b", "-a", "extra"};
- // EXPECT_THROW(run(), CLI::CallForHelp);
+ // CHECK_THROWS_AS (run(), CLI::CallForHelp);
}
// #209
-TEST_F(TApp, CustomUserSepParse) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse", "[app]") {
std::vector<int> vals{1, 2, 3};
args = {"--idx", "1,2,3"};
auto opt = app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
std::vector<int> vals2;
// check that the results vector gets the results in the same way
opt->results(vals2);
- EXPECT_EQ(vals2, vals);
+ CHECK(vals == vals2);
app.remove_option(opt);
app.add_option("--idx", vals)->delimiter(',')->capture_default_str();
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
}
// #209
-TEST_F(TApp, DefaultUserSepParse) {
+TEST_CASE_METHOD(TApp, "DefaultUserSepParse", "[app]") {
std::vector<std::string> vals;
args = {"--idx", "1 2 3", "4 5 6"};
auto opt = app.add_option("--idx", vals, "");
run();
- EXPECT_EQ(vals, std::vector<std::string>({"1 2 3", "4 5 6"}));
+ CHECK(std::vector<std::string>({"1 2 3", "4 5 6"}) == vals);
opt->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<std::string>({"1 2 3", "4 5 6"}));
+ CHECK(std::vector<std::string>({"1 2 3", "4 5 6"}) == vals);
}
// #209
-TEST_F(TApp, BadUserSepParse) {
+TEST_CASE_METHOD(TApp, "BadUserSepParse", "[app]") {
std::vector<int> vals;
app.add_option("--idx", vals);
args = {"--idx", "1,2,3"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
// #209
-TEST_F(TApp, CustomUserSepParse2) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse2", "[app]") {
std::vector<int> vals{1, 2, 3};
args = {"--idx", "1,2,"};
auto opt = app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
app.remove_option(opt);
app.add_option("--idx", vals, "")->delimiter(',')->capture_default_str();
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
}
-TEST_F(TApp, CustomUserSepParseFunction) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParseFunction", "[app]") {
std::vector<int> vals{1, 2, 3};
args = {"--idx", "1,2,3"};
app.add_option_function<std::vector<int>>("--idx", [&vals](std::vector<int> v) { vals = std::move(v); })
->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
}
// delimiter removal
-TEST_F(TApp, CustomUserSepParseToggle) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParseToggle", "[app]") {
std::vector<std::string> vals;
args = {"--idx", "1,2,3"};
auto opt = app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<std::string>({"1", "2", "3"}));
+ CHECK(std::vector<std::string>({"1", "2", "3"}) == vals);
opt->delimiter('\0');
run();
- EXPECT_EQ(vals, std::vector<std::string>({"1,2,3"}));
+ CHECK(std::vector<std::string>({"1,2,3"}) == vals);
opt->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<std::string>({"1", "2", "3"}));
+ CHECK(std::vector<std::string>({"1", "2", "3"}) == vals);
}
// #209
-TEST_F(TApp, CustomUserSepParse3) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse3", "[app]") {
std::vector<int> vals = {1, 2, 3};
args = {"--idx",
@@ -2217,42 +2216,42 @@ TEST_F(TApp, CustomUserSepParse3) {
"2"};
auto opt = app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
app.remove_option(opt);
app.add_option("--idx", vals, "", false)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
}
// #209
-TEST_F(TApp, CustomUserSepParse4) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse4", "[app]") {
std::vector<int> vals;
args = {"--idx", "1, 2"};
auto opt = app.add_option("--idx", vals)->delimiter(',')->capture_default_str();
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
app.remove_option(opt);
app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
}
// #218
-TEST_F(TApp, CustomUserSepParse5) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse5", "[app]") {
std::vector<std::string> bar;
args = {"this", "is", "a", "test"};
auto opt = app.add_option("bar", bar, "bar");
run();
- EXPECT_EQ(bar, std::vector<std::string>({"this", "is", "a", "test"}));
+ CHECK(std::vector<std::string>({"this", "is", "a", "test"}) == bar);
app.remove_option(opt);
args = {"this", "is", "a", "test"};
app.add_option("bar", bar, "bar")->capture_default_str();
run();
- EXPECT_EQ(bar, std::vector<std::string>({"this", "is", "a", "test"}));
+ CHECK(std::vector<std::string>({"this", "is", "a", "test"}) == bar);
}
diff --git a/packages/CLI11/tests/BoostOptionTypeTest.cpp b/packages/CLI11/tests/BoostOptionTypeTest.cpp
index 3ddd6ae459bded6af8ee6af1c216891d8c061001..2110bcc6540bd881bb4474b0d00df3e21f0582c0 100644
--- a/packages/CLI11/tests/BoostOptionTypeTest.cpp
+++ b/packages/CLI11/tests/BoostOptionTypeTest.cpp
@@ -15,137 +15,112 @@
#include <string>
#include <vector>
-#include "gmock/gmock.h"
-
-namespace boost {
-namespace container {
-
-template <class T> class TApp_container_single_boost : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_single_boost() : TApp() {}
-};
-
-using containerTypes_single_boost =
- ::testing::Types<small_vector<int, 2>, small_vector<int, 3>, flat_set<int>, stable_vector<int>, slist<int>>;
-
-TYPED_TEST_SUITE(TApp_container_single_boost, containerTypes_single_boost, );
-
-TYPED_TEST(TApp_container_single_boost, containerInt_boost) {
-
- auto &cv = TApp_container_single_boost<TypeParam>::cval;
- CLI::Option *opt = (TApp::app).add_option("-v", cv);
-
- TApp::args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
- TApp::run();
- EXPECT_EQ(4u, (TApp::app).count("-v"));
- EXPECT_EQ(4u, cv.size());
+using namespace boost::container;
+
+TEMPLATE_TEST_CASE("Boost container single",
+ "[boost][optional]",
+ (small_vector<int, 2>),
+ (small_vector<int, 3>),
+ flat_set<int>,
+ stable_vector<int>,
+ slist<int>) {
+ TApp tapp;
+ TestType cv;
+ CLI::Option *opt = tapp.app.add_option("-v", cv);
+
+ tapp.args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
+ tapp.run();
+ CHECK(tapp.app.count("-v") == 4u);
+ CHECK(cv.size() == 4u);
opt->check(CLI::PositiveNumber.application_index(0));
opt->check((!CLI::PositiveNumber).application_index(1));
- EXPECT_NO_THROW(TApp::run());
- EXPECT_EQ(4u, cv.size());
+ CHECK_NOTHROW(tapp.run());
+ CHECK(cv.size() == 4u);
// v[3] would be negative
opt->check(CLI::PositiveNumber.application_index(3));
- EXPECT_THROW(TApp::run(), CLI::ValidationError);
+ CHECK_THROWS_AS(tapp.run(), CLI::ValidationError);
}
-template <class T> class TApp_container_pair_boost : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_pair_boost() : TApp() {}
-};
-
using isp = std::pair<int, std::string>;
-using containerTypes_pair_boost = ::testing::
- Types<stable_vector<isp>, small_vector<isp, 2>, flat_set<isp>, slist<isp>, vector<isp>, flat_map<int, std::string>>;
-TYPED_TEST_SUITE(TApp_container_pair_boost, containerTypes_pair_boost, );
+TEMPLATE_TEST_CASE("Boost container pair",
+ "[boost][optional]",
+ stable_vector<isp>,
+ (small_vector<isp, 2>),
+ flat_set<isp>,
+ slist<isp>,
+ vector<isp>,
+ (flat_map<int, std::string>)) {
-TYPED_TEST(TApp_container_pair_boost, containerPair_boost) {
+ TApp tapp;
+ TestType cv;
- auto &cv = TApp_container_pair_boost<TypeParam>::cval;
- (TApp::app).add_option("--dict", cv);
+ tapp.app.add_option("--dict", cv);
- TApp::args = {"--dict", "1", "str1", "--dict", "3", "str3"};
+ tapp.args = {"--dict", "1", "str1", "--dict", "3", "str3"};
- TApp::run();
- EXPECT_EQ(cv.size(), 2u);
+ tapp.run();
+ CHECK(2u == cv.size());
- TApp::args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
- TApp::run();
- EXPECT_EQ(cv.size(), 3u);
+ tapp.args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
+ tapp.run();
+ CHECK(3u == cv.size());
}
-template <class T> class TApp_container_tuple_boost : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_tuple_boost() : TApp() {}
-};
-
using tup_obj = std::tuple<int, std::string, double>;
-using containerTypes_tuple_boost =
- ::testing::Types<small_vector<tup_obj, 3>, stable_vector<tup_obj>, flat_set<tup_obj>, slist<tup_obj>>;
-TYPED_TEST_SUITE(TApp_container_tuple_boost, containerTypes_tuple_boost, );
+TEMPLATE_TEST_CASE("Boost container tuple",
+ "[boost][optional]",
+ (small_vector<tup_obj, 3>),
+ stable_vector<tup_obj>,
+ flat_set<tup_obj>,
+ slist<tup_obj>) {
+ TApp tapp;
+ TestType cv;
-TYPED_TEST(TApp_container_tuple_boost, containerTuple_boost) {
+ tapp.app.add_option("--dict", cv);
- auto &cv = TApp_container_tuple_boost<TypeParam>::cval;
- (TApp::app).add_option("--dict", cv);
+ tapp.args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
- TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
+ tapp.run();
+ CHECK(2u == cv.size());
- TApp::run();
- EXPECT_EQ(cv.size(), 2u);
-
- TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
- TApp::run();
- EXPECT_EQ(cv.size(), 3u);
+ tapp.args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
+ tapp.run();
+ CHECK(3u == cv.size());
}
using icontainer1 = vector<int>;
using icontainer2 = flat_set<int>;
using icontainer3 = slist<int>;
-using containerTypes_container_boost = ::testing::Types<std::vector<icontainer1>,
- slist<icontainer1>,
- flat_set<icontainer1>,
- small_vector<icontainer1, 2>,
- std::vector<icontainer2>,
- slist<icontainer2>,
- flat_set<icontainer2>,
- stable_vector<icontainer2>,
- static_vector<icontainer3, 10>,
- slist<icontainer3>,
- flat_set<icontainer3>,
- static_vector<icontainer3, 10>>;
-
-template <class T> class TApp_container_container_boost : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_container_boost() : TApp() {}
-};
-
-TYPED_TEST_SUITE(TApp_container_container_boost, containerTypes_container_boost, );
-
-TYPED_TEST(TApp_container_container_boost, containerContainer_boost) {
-
- auto &cv = TApp_container_container_boost<TypeParam>::cval;
- (TApp::app).add_option("--dict", cv);
-
- TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
-
- TApp::run();
- EXPECT_EQ(cv.size(), 2u);
-
- TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
- "3", "3", "3", "3", "3", "3", "3", "3", "3", "-3"};
- TApp::run();
- EXPECT_EQ(cv.size(), 4u);
-}
-} // namespace container
-} // namespace boost
+TEMPLATE_TEST_CASE("Boost container container",
+ "[boost][optional]",
+ std::vector<icontainer1>,
+ slist<icontainer1>,
+ flat_set<icontainer1>,
+ (small_vector<icontainer1, 2>),
+ std::vector<icontainer2>,
+ slist<icontainer2>,
+ flat_set<icontainer2>,
+ stable_vector<icontainer2>,
+ (static_vector<icontainer2, 10>),
+ slist<icontainer3>,
+ flat_set<icontainer3>,
+ (static_vector<icontainer3, 10>)) {
+
+ TApp tapp;
+ TestType cv;
+
+ tapp.app.add_option("--dict", cv);
+
+ tapp.args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
+
+ tapp.run();
+ CHECK(2u == cv.size());
+
+ tapp.args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
+ "3", "3", "3", "3", "3", "3", "3", "3", "3", "-3"};
+ tapp.run();
+ CHECK(4u == cv.size());
+}
diff --git a/packages/CLI11/tests/CMakeLists.txt b/packages/CLI11/tests/CMakeLists.txt
index cce6e30b8f388309113bed5134a4221dc082e6fd..4a86923f6dd7b74a9f51d02785e9f060e0617129 100644
--- a/packages/CLI11/tests/CMakeLists.txt
+++ b/packages/CLI11/tests/CMakeLists.txt
@@ -1,8 +1,3 @@
-if(NOT EXISTS "${CLI11_SOURCE_DIR}/extern/googletest/CMakeLists.txt")
- message(FATAL_ERROR "You have requested tests be built, but googletest is not downloaded. Please run:
- git submodule update --init")
-endif()
-
list(APPEND CMAKE_MODULE_PATH "${CLI11_SOURCE_DIR}/cmake")
if(CLI11_SANITIZERS)
@@ -29,8 +24,6 @@ else()
endmacro()
endif()
-set(GOOGLE_TEST_INDIVIDUAL OFF)
-include(AddGoogletest)
# Add boost to test boost::optional (currently explicitly requested)"
option(CLI11_BOOST "Turn on boost test (currently may fail with Boost 1.70)" OFF)
@@ -70,8 +63,32 @@ endif()
set(CLI11_MULTIONLY_TESTS TimerTest)
-# Only affects current directory, so safe
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+add_library(catch_main main.cpp)
+target_include_directories(catch_main PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
+
+# Currently a required download; could be make to look for existing Catch2, but
+# that would require changing the includes. FetchContent would be better, but
+# requires newer CMake.
+
+set(url https://github.com/philsquared/Catch/releases/download/v2.13.4/catch.hpp)
+file(DOWNLOAD ${url} "${CMAKE_CURRENT_BINARY_DIR}/catch.hpp" STATUS status EXPECTED_HASH SHA256=6e0fa3dd160891a01c1f3b34e8bcd6e0140abe08eca022e390027f27dec2050b)
+list(GET status 0 error)
+if(error)
+ message(FATAL_ERROR "Could not download ${url}")
+endif()
+target_include_directories(catch_main PUBLIC "${CMAKE_CURRENT_BINARY_DIR}")
+
+# Target must already exist
+macro(add_catch_test TESTNAME)
+ target_link_libraries(${TESTNAME} PUBLIC catch_main)
+
+ add_test(${TESTNAME} ${TESTNAME})
+ set_target_properties(${TESTNAME} PROPERTIES FOLDER "Tests")
+ if (CLI11_FORCE_LIBCXX)
+ set_property(TARGET ${T} APPEND_STRING
+ PROPERTY LINK_FLAGS -stdlib=libc++)
+ endif()
+endmacro()
foreach(T IN LISTS CLI11_TESTS)
if(CLI11_CUDA_TESTS)
@@ -86,12 +103,12 @@ foreach(T IN LISTS CLI11_TESTS)
target_link_libraries(${T} PRIVATE CLI11_warnings)
endif()
target_link_libraries(${T} PRIVATE CLI11)
- add_gtest(${T})
+ add_catch_test(${T})
if(CLI11_SINGLE_FILE AND CLI11_SINGLE_FILE_TESTS)
add_executable(${T}_Single ${T}.cpp)
target_link_libraries(${T}_Single PRIVATE CLI11_SINGLE)
- add_gtest(${T}_Single)
+ add_catch_test(${T}_Single)
set_property(TARGET ${T}_Single PROPERTY FOLDER "Tests Single File")
endif()
endforeach()
@@ -100,7 +117,7 @@ foreach(T IN LISTS CLI11_MULTIONLY_TESTS)
add_executable(${T} ${T}.cpp ${CLI11_headers})
add_sanitizers(${T})
target_link_libraries(${T} PUBLIC CLI11)
- add_gtest(${T})
+ add_catch_test(${T})
endforeach()
# Add -Wno-deprecated-declarations to DeprecatedTest
@@ -123,7 +140,7 @@ target_link_libraries(link_test_1 PUBLIC CLI11)
set_target_properties(link_test_1 PROPERTIES FOLDER "Tests")
add_executable(link_test_2 link_test_2.cpp)
target_link_libraries(link_test_2 PUBLIC CLI11 link_test_1)
-add_gtest(link_test_2)
+add_catch_test(link_test_2)
if(CLI11_FORCE_LIBCXX)
set_property(TARGET link_test_1 APPEND_STRING
PROPERTY LINK_FLAGS -stdlib=libc++)
diff --git a/packages/CLI11/tests/ComplexTypeTest.cpp b/packages/CLI11/tests/ComplexTypeTest.cpp
index 43c6cd48bab35cdc2a2ad09e6e59ccbc712a9dd6..b9a5d4e51cfc2584b8f199ef9ced5c8be245f8a4 100644
--- a/packages/CLI11/tests/ComplexTypeTest.cpp
+++ b/packages/CLI11/tests/ComplexTypeTest.cpp
@@ -5,11 +5,11 @@
// SPDX-License-Identifier: BSD-3-Clause
#include "app_helper.hpp"
-#include "gmock/gmock.h"
+
#include <complex>
#include <cstdint>
-using ::testing::HasSubstr;
+using Catch::Matchers::Contains;
using cx = std::complex<double>;
@@ -33,7 +33,7 @@ add_option(CLI::App &app, std::string name, cx &variable, std::string descriptio
return opt;
}
-TEST_F(TApp, AddingComplexParser) {
+TEST_CASE_METHOD(TApp, "AddingComplexParser", "[complex]") {
cx comp{0, 0};
add_option(app, "-c,--complex", comp);
@@ -41,27 +41,27 @@ TEST_F(TApp, AddingComplexParser) {
run();
- EXPECT_DOUBLE_EQ(1.5, comp.real());
- EXPECT_DOUBLE_EQ(2.5, comp.imag());
+ CHECK(comp.real() == Approx(1.5));
+ CHECK(comp.imag() == Approx(2.5));
}
-TEST_F(TApp, DefaultedComplex) {
+TEST_CASE_METHOD(TApp, "DefaultedComplex", "[complex]") {
cx comp{1, 2};
add_option(app, "-c,--complex", comp, "", true);
args = {"-c", "4", "3"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
- EXPECT_DOUBLE_EQ(1, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
// an example of custom complex number converter that can be used to add new parsing options
@@ -117,7 +117,7 @@ template <> bool lexical_cast<std::complex<double>>(const std::string &input, st
} // namespace detail
} // namespace CLI
-TEST_F(TApp, AddingComplexParserDetail) {
+TEST_CASE_METHOD(TApp, "AddingComplexParserDetail", "[complex]") {
bool skip_tests = false;
try { // check if the library actually supports regex, it is possible to link against a non working regex in the
@@ -131,7 +131,7 @@ TEST_F(TApp, AddingComplexParserDetail) {
if(!rsearch) {
skip_tests = true;
} else {
- EXPECT_EQ(m.size(), 9u);
+ CHECK(9u == m.size());
}
} catch(...) {
@@ -146,14 +146,14 @@ TEST_F(TApp, AddingComplexParserDetail) {
run();
- EXPECT_DOUBLE_EQ(1.5, comp.real());
- EXPECT_DOUBLE_EQ(2.5, comp.imag());
+ CHECK(comp.real() == Approx(1.5));
+ CHECK(comp.imag() == Approx(2.5));
args = {"-c", "1.5-2.5j"};
run();
- EXPECT_DOUBLE_EQ(1.5, comp.real());
- EXPECT_DOUBLE_EQ(-2.5, comp.imag());
+ CHECK(comp.real() == Approx(1.5));
+ CHECK(comp.imag() == Approx(-2.5));
}
}
#endif
@@ -170,7 +170,7 @@ class complex_new {
double val2_{0.0};
};
-TEST_F(TApp, newComplex) {
+TEST_CASE_METHOD(TApp, "newComplex", "[complex]") {
complex_new cval;
static_assert(CLI::detail::is_complex<complex_new>::value, "complex new does not register as a complex type");
static_assert(CLI::detail::classify_object<complex_new>::value == CLI::detail::object_category::complex_number,
@@ -180,12 +180,12 @@ TEST_F(TApp, newComplex) {
run();
- EXPECT_DOUBLE_EQ(1.5, cval.real());
- EXPECT_DOUBLE_EQ(2.5, cval.imag());
+ CHECK(cval.real() == Approx(1.5));
+ CHECK(cval.imag() == Approx(2.5));
args = {"-c", "1.5-2.5j"};
run();
- EXPECT_DOUBLE_EQ(1.5, cval.real());
- EXPECT_DOUBLE_EQ(-2.5, cval.imag());
+ CHECK(cval.real() == Approx(1.5));
+ CHECK(cval.imag() == Approx(-2.5));
}
diff --git a/packages/CLI11/tests/ConfigFileTest.cpp b/packages/CLI11/tests/ConfigFileTest.cpp
index d8b19d142aff335f13e872d38113a405b54c840c..12fa88c10a3949c218b246c1b6a9ddd429f9f309 100644
--- a/packages/CLI11/tests/ConfigFileTest.cpp
+++ b/packages/CLI11/tests/ConfigFileTest.cpp
@@ -6,63 +6,61 @@
#include "app_helper.hpp"
-#include "gmock/gmock.h"
#include <cstdio>
#include <sstream>
-using ::testing::HasSubstr;
-using ::testing::Not;
+using Catch::Matchers::Contains;
-TEST(StringBased, convert_arg_for_ini) {
+TEST_CASE("StringBased: convert_arg_for_ini", "[config]") {
- EXPECT_EQ(CLI::detail::convert_arg_for_ini(std::string{}), "\"\"");
+ CHECK("\"\"" == CLI::detail::convert_arg_for_ini(std::string{}));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("true"), "true");
+ CHECK("true" == CLI::detail::convert_arg_for_ini("true"));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("nan"), "nan");
+ CHECK("nan" == CLI::detail::convert_arg_for_ini("nan"));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("happy hippo"), "\"happy hippo\"");
+ CHECK("\"happy hippo\"" == CLI::detail::convert_arg_for_ini("happy hippo"));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("47"), "47");
+ CHECK("47" == CLI::detail::convert_arg_for_ini("47"));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("47.365225"), "47.365225");
+ CHECK("47.365225" == CLI::detail::convert_arg_for_ini("47.365225"));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("+3.28e-25"), "+3.28e-25");
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("-22E14"), "-22E14");
+ CHECK("+3.28e-25" == CLI::detail::convert_arg_for_ini("+3.28e-25"));
+ CHECK("-22E14" == CLI::detail::convert_arg_for_ini("-22E14"));
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("a"), "'a'");
+ CHECK("'a'" == CLI::detail::convert_arg_for_ini("a"));
// hex
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("0x5461FAED"), "0x5461FAED");
+ CHECK("0x5461FAED" == CLI::detail::convert_arg_for_ini("0x5461FAED"));
// hex fail
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("0x5461FAEG"), "\"0x5461FAEG\"");
+ CHECK("\"0x5461FAEG\"" == CLI::detail::convert_arg_for_ini("0x5461FAEG"));
// octal
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("0o546123567"), "0o546123567");
+ CHECK("0o546123567" == CLI::detail::convert_arg_for_ini("0o546123567"));
// octal fail
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("0o546123587"), "\"0o546123587\"");
+ CHECK("\"0o546123587\"" == CLI::detail::convert_arg_for_ini("0o546123587"));
// binary
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("0b01101110010"), "0b01101110010");
+ CHECK("0b01101110010" == CLI::detail::convert_arg_for_ini("0b01101110010"));
// binary fail
- EXPECT_EQ(CLI::detail::convert_arg_for_ini("0b01102110010"), "\"0b01102110010\"");
+ CHECK("\"0b01102110010\"" == CLI::detail::convert_arg_for_ini("0b01102110010"));
}
-TEST(StringBased, IniJoin) {
+TEST_CASE("StringBased: IniJoin", "[config]") {
std::vector<std::string> items = {"one", "two", "three four"};
std::string result = "\"one\" \"two\" \"three four\"";
- EXPECT_EQ(CLI::detail::ini_join(items, ' ', '\0', '\0'), result);
+ CHECK(result == CLI::detail::ini_join(items, ' ', '\0', '\0'));
result = "[\"one\", \"two\", \"three four\"]";
- EXPECT_EQ(CLI::detail::ini_join(items), result);
+ CHECK(result == CLI::detail::ini_join(items));
result = "{\"one\"; \"two\"; \"three four\"}";
- EXPECT_EQ(CLI::detail::ini_join(items, ';', '{', '}'), result);
+ CHECK(result == CLI::detail::ini_join(items, ';', '{', '}'));
}
-TEST(StringBased, First) {
+TEST_CASE("StringBased: First", "[config]") {
std::stringstream ofile;
ofile << "one=three\n";
@@ -72,16 +70,16 @@ TEST(StringBased, First) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(2u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(1).name);
- EXPECT_EQ(1u, output.at(1).inputs.size());
- EXPECT_EQ("four", output.at(1).inputs.at(0));
+ CHECK(output.size() == 2u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).name == "two");
+ CHECK(output.at(1).inputs.size() == 1u);
+ CHECK(output.at(1).inputs.at(0) == "four");
}
-TEST(StringBased, FirstWithComments) {
+TEST_CASE("StringBased: FirstWithComments", "[config]") {
std::stringstream ofile;
ofile << ";this is a comment\n";
@@ -93,16 +91,16 @@ TEST(StringBased, FirstWithComments) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(2u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(1).name);
- EXPECT_EQ(1u, output.at(1).inputs.size());
- EXPECT_EQ("four", output.at(1).inputs.at(0));
+ CHECK(output.size() == 2u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).name == "two");
+ CHECK(output.at(1).inputs.size() == 1u);
+ CHECK(output.at(1).inputs.at(0) == "four");
}
-TEST(StringBased, Quotes) {
+TEST_CASE("StringBased: Quotes", "[config]") {
std::stringstream ofile;
ofile << R"(one = "three")" << '\n';
@@ -113,19 +111,19 @@ TEST(StringBased, Quotes) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(3u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(1).name);
- EXPECT_EQ(1u, output.at(1).inputs.size());
- EXPECT_EQ("four", output.at(1).inputs.at(0));
- EXPECT_EQ("five", output.at(2).name);
- EXPECT_EQ(1u, output.at(2).inputs.size());
- EXPECT_EQ("six and seven", output.at(2).inputs.at(0));
+ CHECK(output.size() == 3u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).name == "two");
+ CHECK(output.at(1).inputs.size() == 1u);
+ CHECK(output.at(1).inputs.at(0) == "four");
+ CHECK(output.at(2).name == "five");
+ CHECK(output.at(2).inputs.size() == 1u);
+ CHECK(output.at(2).inputs.at(0) == "six and seven");
}
-TEST(StringBased, Vector) {
+TEST_CASE("StringBased: Vector", "[config]") {
std::stringstream ofile;
ofile << "one = three\n";
@@ -136,21 +134,21 @@ TEST(StringBased, Vector) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(3u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(1).name);
- EXPECT_EQ(1u, output.at(1).inputs.size());
- EXPECT_EQ("four", output.at(1).inputs.at(0));
- EXPECT_EQ("five", output.at(2).name);
- EXPECT_EQ(3u, output.at(2).inputs.size());
- EXPECT_EQ("six", output.at(2).inputs.at(0));
- EXPECT_EQ("and", output.at(2).inputs.at(1));
- EXPECT_EQ("seven", output.at(2).inputs.at(2));
-}
-
-TEST(StringBased, TomlVector) {
+ CHECK(output.size() == 3u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).name == "two");
+ CHECK(output.at(1).inputs.size() == 1u);
+ CHECK(output.at(1).inputs.at(0) == "four");
+ CHECK(output.at(2).name == "five");
+ CHECK(output.at(2).inputs.size() == 3u);
+ CHECK(output.at(2).inputs.at(0) == "six");
+ CHECK(output.at(2).inputs.at(1) == "and");
+ CHECK(output.at(2).inputs.at(2) == "seven");
+}
+
+TEST_CASE("StringBased: TomlVector", "[config]") {
std::stringstream ofile;
ofile << "one = [three]\n";
@@ -166,32 +164,32 @@ TEST(StringBased, TomlVector) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(5u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(1).name);
- EXPECT_EQ(1u, output.at(1).inputs.size());
- EXPECT_EQ("four", output.at(1).inputs.at(0));
- EXPECT_EQ("five", output.at(2).name);
- EXPECT_EQ(3u, output.at(2).inputs.size());
- EXPECT_EQ("six", output.at(2).inputs.at(0));
- EXPECT_EQ("and", output.at(2).inputs.at(1));
- EXPECT_EQ("seven", output.at(2).inputs.at(2));
- EXPECT_EQ("eight", output.at(3).name);
- EXPECT_EQ(4u, output.at(3).inputs.size());
- EXPECT_EQ("nine", output.at(3).inputs.at(0));
- EXPECT_EQ("ten", output.at(3).inputs.at(1));
- EXPECT_EQ("eleven", output.at(3).inputs.at(2));
- EXPECT_EQ("twelve", output.at(3).inputs.at(3));
- EXPECT_EQ("one_more", output.at(4).name);
- EXPECT_EQ(3u, output.at(4).inputs.size());
- EXPECT_EQ("one", output.at(4).inputs.at(0));
- EXPECT_EQ("two", output.at(4).inputs.at(1));
- EXPECT_EQ("three", output.at(4).inputs.at(2));
-}
-
-TEST(StringBased, Spaces) {
+ CHECK(output.size() == 5u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).name == "two");
+ CHECK(output.at(1).inputs.size() == 1u);
+ CHECK(output.at(1).inputs.at(0) == "four");
+ CHECK(output.at(2).name == "five");
+ CHECK(output.at(2).inputs.size() == 3u);
+ CHECK(output.at(2).inputs.at(0) == "six");
+ CHECK(output.at(2).inputs.at(1) == "and");
+ CHECK(output.at(2).inputs.at(2) == "seven");
+ CHECK(output.at(3).name == "eight");
+ CHECK(output.at(3).inputs.size() == 4u);
+ CHECK(output.at(3).inputs.at(0) == "nine");
+ CHECK(output.at(3).inputs.at(1) == "ten");
+ CHECK(output.at(3).inputs.at(2) == "eleven");
+ CHECK(output.at(3).inputs.at(3) == "twelve");
+ CHECK(output.at(4).name == "one_more");
+ CHECK(output.at(4).inputs.size() == 3u);
+ CHECK(output.at(4).inputs.at(0) == "one");
+ CHECK(output.at(4).inputs.at(1) == "two");
+ CHECK(output.at(4).inputs.at(2) == "three");
+}
+
+TEST_CASE("StringBased: Spaces", "[config]") {
std::stringstream ofile;
ofile << "one = three\n";
@@ -201,16 +199,16 @@ TEST(StringBased, Spaces) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(2u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(1).name);
- EXPECT_EQ(1u, output.at(1).inputs.size());
- EXPECT_EQ("four", output.at(1).inputs.at(0));
+ CHECK(output.size() == 2u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).name == "two");
+ CHECK(output.at(1).inputs.size() == 1u);
+ CHECK(output.at(1).inputs.at(0) == "four");
}
-TEST(StringBased, Sections) {
+TEST_CASE("StringBased: Sections", "[config]") {
std::stringstream ofile;
ofile << "one=three\n";
@@ -221,18 +219,18 @@ TEST(StringBased, Sections) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(4u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("two", output.at(2).name);
- EXPECT_EQ("second", output.at(2).parents.at(0));
- EXPECT_EQ(1u, output.at(2).inputs.size());
- EXPECT_EQ("four", output.at(2).inputs.at(0));
- EXPECT_EQ("second.two", output.at(2).fullname());
+ CHECK(output.size() == 4u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(2).name == "two");
+ CHECK(output.at(2).parents.at(0) == "second");
+ CHECK(output.at(2).inputs.size() == 1u);
+ CHECK(output.at(2).inputs.at(0) == "four");
+ CHECK(output.at(2).fullname() == "second.two");
}
-TEST(StringBased, SpacesSections) {
+TEST_CASE("StringBased: SpacesSections", "[config]") {
std::stringstream ofile;
ofile << "one=three\n\n";
@@ -244,19 +242,19 @@ TEST(StringBased, SpacesSections) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
- EXPECT_EQ(4u, output.size());
- EXPECT_EQ("one", output.at(0).name);
- EXPECT_EQ(1u, output.at(0).inputs.size());
- EXPECT_EQ("three", output.at(0).inputs.at(0));
- EXPECT_EQ("second", output.at(1).parents.at(0));
- EXPECT_EQ("++", output.at(1).name);
- EXPECT_EQ("two", output.at(2).name);
- EXPECT_EQ(1u, output.at(2).parents.size());
- EXPECT_EQ("second", output.at(2).parents.at(0));
- EXPECT_EQ(1u, output.at(2).inputs.size());
- EXPECT_EQ("four", output.at(2).inputs.at(0));
- EXPECT_EQ("second", output.at(3).parents.at(0));
- EXPECT_EQ("--", output.at(3).name);
+ CHECK(output.size() == 4u);
+ CHECK(output.at(0).name == "one");
+ CHECK(output.at(0).inputs.size() == 1u);
+ CHECK(output.at(0).inputs.at(0) == "three");
+ CHECK(output.at(1).parents.at(0) == "second");
+ CHECK(output.at(1).name == "++");
+ CHECK(output.at(2).name == "two");
+ CHECK(output.at(2).parents.size() == 1u);
+ CHECK(output.at(2).parents.at(0) == "second");
+ CHECK(output.at(2).inputs.size() == 1u);
+ CHECK(output.at(2).inputs.at(0) == "four");
+ CHECK(output.at(3).parents.at(0) == "second");
+ CHECK(output.at(3).name == "--");
}
// check function to make sure that open sections match close sections
@@ -284,7 +282,7 @@ bool checkSections(const std::vector<CLI::ConfigItem> &output) {
}
return open.empty();
}
-TEST(StringBased, Layers) {
+TEST_CASE("StringBased: Layers", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -298,11 +296,11 @@ TEST(StringBased, Layers) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 4 openings and 4 closings
- EXPECT_EQ(10u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 10u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, LayersSkip) {
+TEST_CASE("StringBased: LayersSkip", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -314,11 +312,11 @@ TEST(StringBased, LayersSkip) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 4 openings and 4 closings
- EXPECT_EQ(10u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 10u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, LayersSkipOrdered) {
+TEST_CASE("StringBased: LayersSkipOrdered", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -330,11 +328,11 @@ TEST(StringBased, LayersSkipOrdered) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 4 openings and 4 closings
- EXPECT_EQ(12u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 12u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, LayersChange) {
+TEST_CASE("StringBased: LayersChange", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -346,11 +344,11 @@ TEST(StringBased, LayersChange) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 3 openings and 3 closings
- EXPECT_EQ(8u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 8u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, Layers2LevelChange) {
+TEST_CASE("StringBased: Layers2LevelChange", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -362,11 +360,11 @@ TEST(StringBased, Layers2LevelChange) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 5 openings and 5 closings
- EXPECT_EQ(12u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 12u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, Layers3LevelChange) {
+TEST_CASE("StringBased: Layers3LevelChange", "[config]") {
std::stringstream ofile;
ofile << "[other.sub2.subsub.cmd]\n";
@@ -377,11 +375,11 @@ TEST(StringBased, Layers3LevelChange) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 1 flags and 7 openings and 7 closings
- EXPECT_EQ(15u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 15u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, newSegment) {
+TEST_CASE("StringBased: newSegment", "[config]") {
std::stringstream ofile;
ofile << "[other.sub2.subsub.cmd]\n";
@@ -393,11 +391,11 @@ TEST(StringBased, newSegment) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 5 openings and 5 closings
- EXPECT_EQ(12u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 12u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, LayersDirect) {
+TEST_CASE("StringBased: LayersDirect", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -409,11 +407,11 @@ TEST(StringBased, LayersDirect) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 2 flags and 4 openings and 4 closings
- EXPECT_EQ(10u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 10u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, LayersComplex) {
+TEST_CASE("StringBased: LayersComplex", "[config]") {
std::stringstream ofile;
ofile << "simple = true\n\n";
@@ -429,15 +427,15 @@ TEST(StringBased, LayersComplex) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
// 4 flags and 6 openings and 6 closings
- EXPECT_EQ(16u, output.size());
- EXPECT_TRUE(checkSections(output));
+ CHECK(output.size() == 16u);
+ CHECK(checkSections(output));
}
-TEST(StringBased, file_error) {
- EXPECT_THROW(std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_file("nonexist_file"), CLI::FileError);
+TEST_CASE("StringBased: file_error", "[config]") {
+ CHECK_THROWS_AS(CLI::ConfigINI().from_file("nonexist_file"), CLI::FileError);
}
-TEST_F(TApp, IniNotRequired) {
+TEST_CASE_METHOD(TApp, "IniNotRequired", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -459,22 +457,22 @@ TEST_F(TApp, IniNotRequired) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(99, two);
- EXPECT_EQ(3, three);
+ CHECK(one == 1);
+ CHECK(two == 99);
+ CHECK(three == 3);
one = two = three = 0;
args = {"--one=1", "--two=2"};
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
- EXPECT_EQ(app["--config"]->as<std::string>(), "TestIniTmp.ini");
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
+ CHECK("TestIniTmp.ini" == app["--config"]->as<std::string>());
}
-TEST_F(TApp, IniSuccessOnUnknownOption) {
+TEST_CASE_METHOD(TApp, "IniSuccessOnUnknownOption", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -489,10 +487,10 @@ TEST_F(TApp, IniSuccessOnUnknownOption) {
int two{0};
app.add_option("--two", two);
run();
- EXPECT_EQ(99, two);
+ CHECK(two == 99);
}
-TEST_F(TApp, IniGetRemainingOption) {
+TEST_CASE_METHOD(TApp, "IniGetRemainingOption", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -508,12 +506,12 @@ TEST_F(TApp, IniGetRemainingOption) {
int two{0};
app.add_option("--two", two);
- ASSERT_NO_THROW(run());
+ REQUIRE_NOTHROW(run());
std::vector<std::string> ExpectedRemaining = {ExtraOption};
- EXPECT_EQ(app.remaining(), ExpectedRemaining);
+ CHECK(ExpectedRemaining == app.remaining());
}
-TEST_F(TApp, IniGetNoRemaining) {
+TEST_CASE_METHOD(TApp, "IniGetNoRemaining", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -526,26 +524,26 @@ TEST_F(TApp, IniGetNoRemaining) {
int two{0};
app.add_option("--two", two);
- ASSERT_NO_THROW(run());
- EXPECT_EQ(app.remaining().size(), 0u);
+ REQUIRE_NOTHROW(run());
+ CHECK(0u == app.remaining().size());
}
-TEST_F(TApp, IniRequiredNoDefault) {
+TEST_CASE_METHOD(TApp, "IniRequiredNoDefault", "[config]") {
app.set_config("--config")->required();
int two{0};
app.add_option("--two", two);
- ASSERT_THROW(run(), CLI::FileError);
+ REQUIRE_THROWS_AS(run(), CLI::FileError);
}
-TEST_F(TApp, IniNotRequiredNoDefault) {
+TEST_CASE_METHOD(TApp, "IniNotRequiredNoDefault", "[config]") {
app.set_config("--config");
int two{0};
app.add_option("--two", two);
- ASSERT_NO_THROW(run());
+ REQUIRE_NOTHROW(run());
}
/// Define a class for testing purposes that does bad things
@@ -557,7 +555,7 @@ class EvilConfig : public CLI::Config {
virtual std::vector<CLI::ConfigItem> from_config(std::istream &) const { throw CLI::FileError("evil"); }
};
-TEST_F(TApp, IniRequiredbadConfigurator) {
+TEST_CASE_METHOD(TApp, "IniRequiredbadConfigurator", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -572,10 +570,10 @@ TEST_F(TApp, IniRequiredbadConfigurator) {
app.config_formatter(std::make_shared<EvilConfig>());
int two{0};
app.add_option("--two", two);
- ASSERT_THROW(run(), CLI::FileError);
+ REQUIRE_THROWS_AS(run(), CLI::FileError);
}
-TEST_F(TApp, IniNotRequiredbadConfigurator) {
+TEST_CASE_METHOD(TApp, "IniNotRequiredbadConfigurator", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -590,10 +588,10 @@ TEST_F(TApp, IniNotRequiredbadConfigurator) {
app.config_formatter(std::make_shared<EvilConfig>());
int two{0};
app.add_option("--two", two);
- ASSERT_NO_THROW(run());
+ REQUIRE_NOTHROW(run());
}
-TEST_F(TApp, IniNotRequiredNotDefault) {
+TEST_CASE_METHOD(TApp, "IniNotRequiredNotDefault", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
TempFile tmpini2{"TestIniTmp2.ini"};
@@ -620,19 +618,19 @@ TEST_F(TApp, IniNotRequiredNotDefault) {
app.add_option("--three", three);
run();
- EXPECT_EQ(app["--config"]->as<std::string>(), tmpini.c_str());
- EXPECT_EQ(99, two);
- EXPECT_EQ(3, three);
+ CHECK(tmpini.c_str() == app["--config"]->as<std::string>());
+ CHECK(two == 99);
+ CHECK(three == 3);
args = {"--config", tmpini2};
run();
- EXPECT_EQ(98, two);
- EXPECT_EQ(4, three);
- EXPECT_EQ(app.get_config_ptr()->as<std::string>(), tmpini2.c_str());
+ CHECK(two == 98);
+ CHECK(three == 4);
+ CHECK(tmpini2.c_str() == app.get_config_ptr()->as<std::string>());
}
-TEST_F(TApp, MultiConfig) {
+TEST_CASE_METHOD(TApp, "MultiConfig", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
TempFile tmpini2{"TestIniTmp2.ini"};
@@ -661,19 +659,19 @@ TEST_F(TApp, MultiConfig) {
args = {"--config", tmpini2, "--config", tmpini};
run();
- EXPECT_EQ(99, two);
- EXPECT_EQ(3, three);
- EXPECT_EQ(55, one);
+ CHECK(two == 99);
+ CHECK(three == 3);
+ CHECK(one == 55);
args = {"--config", tmpini, "--config", tmpini2};
run();
- EXPECT_EQ(99, two);
- EXPECT_EQ(4, three);
- EXPECT_EQ(55, one);
+ CHECK(two == 99);
+ CHECK(three == 4);
+ CHECK(one == 55);
}
-TEST_F(TApp, MultiConfig_single) {
+TEST_CASE_METHOD(TApp, "MultiConfig_single", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
TempFile tmpini2{"TestIniTmp2.ini"};
@@ -702,37 +700,37 @@ TEST_F(TApp, MultiConfig_single) {
args = {"--config", tmpini2, "--config", tmpini};
run();
- EXPECT_EQ(99, two);
- EXPECT_EQ(3, three);
- EXPECT_EQ(0, one);
+ CHECK(two == 99);
+ CHECK(three == 3);
+ CHECK(one == 0);
two = 0;
args = {"--config", tmpini, "--config", tmpini2};
run();
- EXPECT_EQ(0, two);
- EXPECT_EQ(4, three);
- EXPECT_EQ(55, one);
+ CHECK(two == 0);
+ CHECK(three == 4);
+ CHECK(one == 55);
}
-TEST_F(TApp, IniRequiredNotFound) {
+TEST_CASE_METHOD(TApp, "IniRequiredNotFound", "[config]") {
std::string noini = "TestIniNotExist.ini";
app.set_config("--config", noini, "", true);
- EXPECT_THROW(run(), CLI::FileError);
+ CHECK_THROWS_AS(run(), CLI::FileError);
}
-TEST_F(TApp, IniNotRequiredPassedNotFound) {
+TEST_CASE_METHOD(TApp, "IniNotRequiredPassedNotFound", "[config]") {
std::string noini = "TestIniNotExist.ini";
app.set_config("--config", "", "", false);
args = {"--config", noini};
- EXPECT_THROW(run(), CLI::FileError);
+ CHECK_THROWS_AS(run(), CLI::FileError);
}
-TEST_F(TApp, IniOverwrite) {
+TEST_CASE_METHOD(TApp, "IniOverwrite", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
{
@@ -751,10 +749,10 @@ TEST_F(TApp, IniOverwrite) {
run();
- EXPECT_EQ(99, two);
+ CHECK(two == 99);
}
-TEST_F(TApp, IniRequired) {
+TEST_CASE_METHOD(TApp, "IniRequired", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -775,28 +773,28 @@ TEST_F(TApp, IniRequired) {
args = {"--one=1"};
run();
- EXPECT_EQ(one, 1);
- EXPECT_EQ(two, 99);
- EXPECT_EQ(three, 3);
+ CHECK(1 == one);
+ CHECK(99 == two);
+ CHECK(3 == three);
one = two = three = 0;
args = {"--one=1", "--two=2"};
- EXPECT_NO_THROW(run());
- EXPECT_EQ(one, 1);
- EXPECT_EQ(two, 2);
- EXPECT_EQ(three, 3);
+ CHECK_NOTHROW(run());
+ CHECK(1 == one);
+ CHECK(2 == two);
+ CHECK(3 == three);
args = {};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--two=2"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(TApp, IniVector) {
+TEST_CASE_METHOD(TApp, "IniVector", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -815,10 +813,10 @@ TEST_F(TApp, IniVector) {
run();
- EXPECT_EQ(std::vector<int>({2, 3}), two);
- EXPECT_EQ(std::vector<int>({1, 2, 3}), three);
+ CHECK(two == std::vector<int>({2, 3}));
+ CHECK(three == std::vector<int>({1, 2, 3}));
}
-TEST_F(TApp, TOMLVector) {
+TEST_CASE_METHOD(TApp, "TOMLVector", "[config]") {
TempFile tmptoml{"TestTomlTmp.toml"};
@@ -838,11 +836,11 @@ TEST_F(TApp, TOMLVector) {
run();
- EXPECT_EQ(std::vector<int>({2, 3}), two);
- EXPECT_EQ(std::vector<int>({1, 2, 3}), three);
+ CHECK(two == std::vector<int>({2, 3}));
+ CHECK(three == std::vector<int>({1, 2, 3}));
}
-TEST_F(TApp, ColonValueSep) {
+TEST_CASE_METHOD(TApp, "ColonValueSep", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -864,11 +862,11 @@ TEST_F(TApp, ColonValueSep) {
run();
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
+ CHECK(two == 2);
+ CHECK(three == 3);
}
-TEST_F(TApp, TOMLVectordirect) {
+TEST_CASE_METHOD(TApp, "TOMLVectordirect", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -890,11 +888,11 @@ TEST_F(TApp, TOMLVectordirect) {
run();
- EXPECT_EQ(std::vector<int>({2, 3}), two);
- EXPECT_EQ(std::vector<int>({1, 2, 3}), three);
+ CHECK(two == std::vector<int>({2, 3}));
+ CHECK(three == std::vector<int>({1, 2, 3}));
}
-TEST_F(TApp, TOMLStringVector) {
+TEST_CASE_METHOD(TApp, "TOMLStringVector", "[config]") {
TempFile tmptoml{"TestTomlTmp.toml"};
@@ -914,11 +912,11 @@ TEST_F(TApp, TOMLStringVector) {
run();
- EXPECT_EQ(std::vector<std::string>({"2", "3"}), two);
- EXPECT_EQ(std::vector<std::string>({"1", "2", "3"}), three);
+ CHECK(two == std::vector<std::string>({"2", "3"}));
+ CHECK(three == std::vector<std::string>({"1", "2", "3"}));
}
-TEST_F(TApp, IniVectorCsep) {
+TEST_CASE_METHOD(TApp, "IniVectorCsep", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -938,11 +936,11 @@ TEST_F(TApp, IniVectorCsep) {
run();
- EXPECT_EQ(std::vector<int>({2, 3}), two);
- EXPECT_EQ(std::vector<int>({1, 2, 3}), three);
+ CHECK(two == std::vector<int>({2, 3}));
+ CHECK(three == std::vector<int>({1, 2, 3}));
}
-TEST_F(TApp, IniVectorMultiple) {
+TEST_CASE_METHOD(TApp, "IniVectorMultiple", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -965,11 +963,11 @@ TEST_F(TApp, IniVectorMultiple) {
run();
- EXPECT_EQ(std::vector<int>({2, 3}), two);
- EXPECT_EQ(std::vector<int>({1, 2, 3}), three);
+ CHECK(two == std::vector<int>({2, 3}));
+ CHECK(three == std::vector<int>({1, 2, 3}));
}
-TEST_F(TApp, IniLayered) {
+TEST_CASE_METHOD(TApp, "IniLayered", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -993,15 +991,15 @@ TEST_F(TApp, IniLayered) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
- EXPECT_EQ(subcom->count(), 0U);
- EXPECT_FALSE(*subcom);
+ CHECK(0U == subcom->count());
+ CHECK(!*subcom);
}
-TEST_F(TApp, IniLayeredDotSection) {
+TEST_CASE_METHOD(TApp, "IniLayeredDotSection", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1026,15 +1024,15 @@ TEST_F(TApp, IniLayeredDotSection) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
- EXPECT_EQ(subcom->count(), 0U);
- EXPECT_FALSE(*subcom);
+ CHECK(0U == subcom->count());
+ CHECK(!*subcom);
}
-TEST_F(TApp, IniSubcommandConfigurable) {
+TEST_CASE_METHOD(TApp, "IniSubcommandConfigurable", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1059,16 +1057,16 @@ TEST_F(TApp, IniSubcommandConfigurable) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
- EXPECT_EQ(subcom->count(), 1U);
- EXPECT_TRUE(*subcom);
- EXPECT_TRUE(app.got_subcommand(subcom));
+ CHECK(1U == subcom->count());
+ CHECK(*subcom);
+ CHECK(app.got_subcommand(subcom));
}
-TEST_F(TApp, IniSubcommandConfigurablePreParse) {
+TEST_CASE_METHOD(TApp, "IniSubcommandConfigurablePreParse", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1098,18 +1096,18 @@ TEST_F(TApp, IniSubcommandConfigurablePreParse) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
- EXPECT_EQ(0, four);
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
+ CHECK(four == 0);
- EXPECT_EQ(parse_c.size(), 1U);
- EXPECT_EQ(parse_c[0], 2U);
+ CHECK(1U == parse_c.size());
+ CHECK(2U == parse_c[0]);
- EXPECT_EQ(subcom2->count(), 0U);
+ CHECK(0U == subcom2->count());
}
-TEST_F(TApp, IniSubcommandConfigurableParseComplete) {
+TEST_CASE_METHOD(TApp, "IniSubcommandConfigurableParseComplete", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1142,19 +1140,19 @@ TEST_F(TApp, IniSubcommandConfigurableParseComplete) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
- EXPECT_EQ(0, four);
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
+ CHECK(four == 0);
- ASSERT_EQ(parse_c.size(), 2u);
- EXPECT_EQ(parse_c[0], 68U);
- EXPECT_EQ(parse_c[1], 58U);
- EXPECT_EQ(subsubcom->count(), 1u);
- EXPECT_EQ(subcom2->count(), 0u);
+ REQUIRE(2u == parse_c.size());
+ CHECK(68U == parse_c[0]);
+ CHECK(58U == parse_c[1]);
+ CHECK(1u == subsubcom->count());
+ CHECK(0u == subcom2->count());
}
-TEST_F(TApp, IniSubcommandMultipleSections) {
+TEST_CASE_METHOD(TApp, "IniSubcommandMultipleSections", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1190,19 +1188,19 @@ TEST_F(TApp, IniSubcommandMultipleSections) {
run();
- EXPECT_EQ(1, one);
- EXPECT_EQ(2, two);
- EXPECT_EQ(3, three);
- EXPECT_EQ(4, four);
+ CHECK(one == 1);
+ CHECK(two == 2);
+ CHECK(three == 3);
+ CHECK(four == 4);
- ASSERT_EQ(parse_c.size(), 2u);
- EXPECT_EQ(parse_c[0], 68U);
- EXPECT_EQ(parse_c[1], 58U);
- EXPECT_EQ(subsubcom->count(), 1u);
- EXPECT_EQ(subcom2->count(), 0u); // not configurable but value is updated
+ REQUIRE(2u == parse_c.size());
+ CHECK(68U == parse_c[0]);
+ CHECK(58U == parse_c[1]);
+ CHECK(1u == subsubcom->count());
+ CHECK(0u == subcom2->count());
}
-TEST_F(TApp, DuplicateSubcommandCallbacks) {
+TEST_CASE_METHOD(TApp, "DuplicateSubcommandCallbacks", "[config]") {
TempFile tmptoml{"TesttomlTmp.toml"};
@@ -1219,14 +1217,14 @@ TEST_F(TApp, DuplicateSubcommandCallbacks) {
int count{0};
foo->callback([&count]() { ++count; });
foo->immediate_callback();
- EXPECT_TRUE(foo->get_immediate_callback());
+ CHECK(foo->get_immediate_callback());
foo->configurable();
run();
- EXPECT_EQ(count, 3);
+ CHECK(3 == count);
}
-TEST_F(TApp, IniFailure) {
+TEST_CASE_METHOD(TApp, "IniFailure", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1238,10 +1236,10 @@ TEST_F(TApp, IniFailure) {
out << "val=1" << std::endl;
}
- EXPECT_THROW(run(), CLI::ConfigError);
+ CHECK_THROWS_AS(run(), CLI::ConfigError);
}
-TEST_F(TApp, IniConfigurable) {
+TEST_CASE_METHOD(TApp, "IniConfigurable", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1255,11 +1253,11 @@ TEST_F(TApp, IniConfigurable) {
out << "val=1" << std::endl;
}
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(value);
+ REQUIRE_NOTHROW(run());
+ CHECK(value);
}
-TEST_F(TApp, IniNotConfigurable) {
+TEST_CASE_METHOD(TApp, "IniNotConfigurable", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1273,10 +1271,10 @@ TEST_F(TApp, IniNotConfigurable) {
out << "val=1" << std::endl;
}
- EXPECT_THROW(run(), CLI::ConfigError);
+ CHECK_THROWS_AS(run(), CLI::ConfigError);
}
-TEST_F(TApp, IniSubFailure) {
+TEST_CASE_METHOD(TApp, "IniSubFailure", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1289,10 +1287,10 @@ TEST_F(TApp, IniSubFailure) {
out << "val=1" << std::endl;
}
- EXPECT_THROW(run(), CLI::ConfigError);
+ CHECK_THROWS_AS(run(), CLI::ConfigError);
}
-TEST_F(TApp, IniNoSubFailure) {
+TEST_CASE_METHOD(TApp, "IniNoSubFailure", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1304,10 +1302,10 @@ TEST_F(TApp, IniNoSubFailure) {
out << "val=1" << std::endl;
}
- EXPECT_THROW(run(), CLI::ConfigError);
+ CHECK_THROWS_AS(run(), CLI::ConfigError);
}
-TEST_F(TApp, IniFlagConvertFailure) {
+TEST_CASE_METHOD(TApp, "IniFlagConvertFailure", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1321,13 +1319,13 @@ TEST_F(TApp, IniFlagConvertFailure) {
run();
bool result{false};
auto *opt = app.get_option("--flag");
- EXPECT_THROW(opt->results(result), CLI::ConversionError);
+ CHECK_THROWS_AS(opt->results(result), CLI::ConversionError);
std::string res;
opt->results(res);
- EXPECT_EQ(res, "moobook");
+ CHECK("moobook" == res);
}
-TEST_F(TApp, IniFlagNumbers) {
+TEST_CASE_METHOD(TApp, "IniFlagNumbers", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1340,11 +1338,11 @@ TEST_F(TApp, IniFlagNumbers) {
out << "flag=3" << std::endl;
}
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(boo);
+ REQUIRE_NOTHROW(run());
+ CHECK(boo);
}
-TEST_F(TApp, IniFlagDual) {
+TEST_CASE_METHOD(TApp, "IniFlagDual", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1358,10 +1356,10 @@ TEST_F(TApp, IniFlagDual) {
out << "flag=1 1" << std::endl;
}
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, IniShort) {
+TEST_CASE_METHOD(TApp, "IniShort", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1374,11 +1372,11 @@ TEST_F(TApp, IniShort) {
out << "f=3" << std::endl;
}
- ASSERT_NO_THROW(run());
- EXPECT_EQ(key, 3);
+ REQUIRE_NOTHROW(run());
+ CHECK(3 == key);
}
-TEST_F(TApp, IniPositional) {
+TEST_CASE_METHOD(TApp, "IniPositional", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1391,11 +1389,11 @@ TEST_F(TApp, IniPositional) {
out << "key=3" << std::endl;
}
- ASSERT_NO_THROW(run());
- EXPECT_EQ(key, 3);
+ REQUIRE_NOTHROW(run());
+ CHECK(3 == key);
}
-TEST_F(TApp, IniEnvironmental) {
+TEST_CASE_METHOD(TApp, "IniEnvironmental", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1408,11 +1406,11 @@ TEST_F(TApp, IniEnvironmental) {
out << "CLI11_TEST_ENV_KEY_TMP=3" << std::endl;
}
- ASSERT_NO_THROW(run());
- EXPECT_EQ(key, 3);
+ REQUIRE_NOTHROW(run());
+ CHECK(3 == key);
}
-TEST_F(TApp, IniFlagText) {
+TEST_CASE_METHOD(TApp, "IniFlagText", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1433,13 +1431,13 @@ TEST_F(TApp, IniFlagText) {
run();
- EXPECT_TRUE(flag1);
- EXPECT_TRUE(flag2);
- EXPECT_FALSE(flag3);
- EXPECT_TRUE(flag4);
+ CHECK(flag1);
+ CHECK(flag2);
+ CHECK(!flag3);
+ CHECK(flag4);
}
-TEST_F(TApp, IniFlags) {
+TEST_CASE_METHOD(TApp, "IniFlags", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -1461,13 +1459,13 @@ TEST_F(TApp, IniFlags) {
run();
- EXPECT_EQ(2, two);
- EXPECT_TRUE(three);
- EXPECT_TRUE(four);
- EXPECT_TRUE(five);
+ CHECK(two == 2);
+ CHECK(three);
+ CHECK(four);
+ CHECK(five);
}
-TEST_F(TApp, IniFalseFlags) {
+TEST_CASE_METHOD(TApp, "IniFalseFlags", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -1489,13 +1487,13 @@ TEST_F(TApp, IniFalseFlags) {
run();
- EXPECT_EQ(-2, two);
- EXPECT_FALSE(three);
- EXPECT_TRUE(four);
- EXPECT_TRUE(five);
+ CHECK(two == -2);
+ CHECK(!three);
+ CHECK(four);
+ CHECK(five);
}
-TEST_F(TApp, IniFalseFlagsDef) {
+TEST_CASE_METHOD(TApp, "IniFalseFlagsDef", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -1517,13 +1515,13 @@ TEST_F(TApp, IniFalseFlagsDef) {
run();
- EXPECT_EQ(-2, two);
- EXPECT_TRUE(three);
- EXPECT_FALSE(four);
- EXPECT_TRUE(five);
+ CHECK(two == -2);
+ CHECK(three);
+ CHECK(!four);
+ CHECK(five);
}
-TEST_F(TApp, IniFalseFlagsDefDisableOverrideError) {
+TEST_CASE_METHOD(TApp, "IniFalseFlagsDefDisableOverrideError", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -1541,10 +1539,10 @@ TEST_F(TApp, IniFalseFlagsDefDisableOverrideError) {
app.add_flag("!--four", four);
app.add_flag("--five", five);
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, IniFalseFlagsDefDisableOverrideSuccess) {
+TEST_CASE_METHOD(TApp, "IniFalseFlagsDefDisableOverrideSuccess", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
@@ -1563,12 +1561,12 @@ TEST_F(TApp, IniFalseFlagsDefDisableOverrideSuccess) {
run();
- EXPECT_EQ(2, two);
- EXPECT_EQ(4, four);
- EXPECT_EQ(15, val);
+ CHECK(two == 2);
+ CHECK(four == 4);
+ CHECK(val == 15);
}
-TEST_F(TApp, TomlOutputSimple) {
+TEST_CASE_METHOD(TApp, "TomlOutputSimple", "[config]") {
int v{0};
app.add_option("--simple", v);
@@ -1578,10 +1576,10 @@ TEST_F(TApp, TomlOutputSimple) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("simple=3\n", str);
+ CHECK(str == "simple=3\n");
}
-TEST_F(TApp, TomlOutputShort) {
+TEST_CASE_METHOD(TApp, "TomlOutputShort", "[config]") {
int v{0};
app.add_option("-s", v);
@@ -1591,10 +1589,10 @@ TEST_F(TApp, TomlOutputShort) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("s=3\n", str);
+ CHECK(str == "s=3\n");
}
-TEST_F(TApp, TomlOutputPositional) {
+TEST_CASE_METHOD(TApp, "TomlOutputPositional", "[config]") {
int v{0};
app.add_option("pos", v);
@@ -1604,11 +1602,11 @@ TEST_F(TApp, TomlOutputPositional) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("pos=3\n", str);
+ CHECK(str == "pos=3\n");
}
// try the output with environmental only arguments
-TEST_F(TApp, TomlOutputEnvironmental) {
+TEST_CASE_METHOD(TApp, "TomlOutputEnvironmental", "[config]") {
put_env("CLI11_TEST_ENV_TMP", "2");
@@ -1617,14 +1615,14 @@ TEST_F(TApp, TomlOutputEnvironmental) {
run();
- EXPECT_EQ(2, val);
+ CHECK(val == 2);
std::string str = app.config_to_str();
- EXPECT_EQ("CLI11_TEST_ENV_TMP=2\n", str);
+ CHECK(str == "CLI11_TEST_ENV_TMP=2\n");
unset_env("CLI11_TEST_ENV_TMP");
}
-TEST_F(TApp, TomlOutputNoConfigurable) {
+TEST_CASE_METHOD(TApp, "TomlOutputNoConfigurable", "[config]") {
int v1{0}, v2{0};
app.add_option("--simple", v1);
@@ -1635,10 +1633,10 @@ TEST_F(TApp, TomlOutputNoConfigurable) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("simple=3\n", str);
+ CHECK(str == "simple=3\n");
}
-TEST_F(TApp, TomlOutputShortSingleDescription) {
+TEST_CASE_METHOD(TApp, "TomlOutputShortSingleDescription", "[config]") {
std::string flag = "some_flag";
const std::string description = "Some short description.";
app.add_flag("--" + flag, description);
@@ -1646,10 +1644,10 @@ TEST_F(TApp, TomlOutputShortSingleDescription) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("# " + description + "\n" + flag + "=false\n"));
+ CHECK_THAT(str, Contains("# " + description + "\n" + flag + "=false\n"));
}
-TEST_F(TApp, TomlOutputShortDoubleDescription) {
+TEST_CASE_METHOD(TApp, "TomlOutputShortDoubleDescription", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
const std::string description1 = "First description.";
@@ -1660,11 +1658,11 @@ TEST_F(TApp, TomlOutputShortDoubleDescription) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(
- str, HasSubstr("# " + description1 + "\n" + flag1 + "=false\n\n# " + description2 + "\n" + flag2 + "=false\n"));
+ std::string ans = "# " + description1 + "\n" + flag1 + "=false\n\n# " + description2 + "\n" + flag2 + "=false\n";
+ CHECK_THAT(str, Contains(ans));
}
-TEST_F(TApp, TomlOutputGroups) {
+TEST_CASE_METHOD(TApp, "TomlOutputGroups", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
const std::string description1 = "First description.";
@@ -1675,11 +1673,11 @@ TEST_F(TApp, TomlOutputGroups) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("group1"));
- EXPECT_THAT(str, HasSubstr("group2"));
+ CHECK_THAT(str, Contains("group1"));
+ CHECK_THAT(str, Contains("group2"));
}
-TEST_F(TApp, TomlOutputHiddenOptions) {
+TEST_CASE_METHOD(TApp, "TomlOutputHiddenOptions", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
double val{12.7};
@@ -1692,18 +1690,18 @@ TEST_F(TApp, TomlOutputHiddenOptions) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("group1"));
- EXPECT_THAT(str, HasSubstr("group2"));
- EXPECT_THAT(str, HasSubstr("dval=12.7"));
+ CHECK_THAT(str, Contains("group1"));
+ CHECK_THAT(str, Contains("group2"));
+ CHECK_THAT(str, Contains("dval=12.7"));
auto loc = str.find("dval=12.7");
auto locg1 = str.find("group1");
- EXPECT_GT(locg1, loc);
+ CHECK(loc < locg1);
// make sure it doesn't come twice
loc = str.find("dval=12.7", loc + 4);
- EXPECT_EQ(loc, std::string::npos);
+ CHECK(std::string::npos == loc);
}
-TEST_F(TApp, TomlOutputMultiLineDescription) {
+TEST_CASE_METHOD(TApp, "TomlOutputMultiLineDescription", "[config]") {
std::string flag = "some_flag";
const std::string description = "Some short description.\nThat has lines.";
app.add_flag("--" + flag, description);
@@ -1711,12 +1709,12 @@ TEST_F(TApp, TomlOutputMultiLineDescription) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("# Some short description.\n"));
- EXPECT_THAT(str, HasSubstr("# That has lines.\n"));
- EXPECT_THAT(str, HasSubstr(flag + "=false\n"));
+ CHECK_THAT(str, Contains("# Some short description.\n"));
+ CHECK_THAT(str, Contains("# That has lines.\n"));
+ CHECK_THAT(str, Contains(flag + "=false\n"));
}
-TEST_F(TApp, TomlOutputOptionGroup) {
+TEST_CASE_METHOD(TApp, "TomlOutputOptionGroup", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
double val{12.7};
@@ -1730,22 +1728,22 @@ TEST_F(TApp, TomlOutputOptionGroup) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("group1"));
- EXPECT_THAT(str, HasSubstr("group2"));
- EXPECT_THAT(str, HasSubstr("dval=12.7"));
- EXPECT_THAT(str, HasSubstr("group3"));
- EXPECT_THAT(str, HasSubstr("g3 desc"));
+ CHECK_THAT(str, Contains("group1"));
+ CHECK_THAT(str, Contains("group2"));
+ CHECK_THAT(str, Contains("dval=12.7"));
+ CHECK_THAT(str, Contains("group3"));
+ CHECK_THAT(str, Contains("g3 desc"));
auto loc = str.find("dval=12.7");
auto locg1 = str.find("group1");
auto locg3 = str.find("group3");
- EXPECT_LT(locg1, loc);
+ CHECK(loc > locg1);
// make sure it doesn't come twice
loc = str.find("dval=12.7", loc + 4);
- EXPECT_EQ(loc, std::string::npos);
- EXPECT_GT(locg3, locg1);
+ CHECK(std::string::npos == loc);
+ CHECK(locg1 < locg3);
}
-TEST_F(TApp, TomlOutputVector) {
+TEST_CASE_METHOD(TApp, "TomlOutputVector", "[config]") {
std::vector<int> v;
app.add_option("--vector", v);
@@ -1755,10 +1753,10 @@ TEST_F(TApp, TomlOutputVector) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("vector=[1, 2, 3]\n", str);
+ CHECK(str == "vector=[1, 2, 3]\n");
}
-TEST_F(TApp, ConfigOutputVectorCustom) {
+TEST_CASE_METHOD(TApp, "ConfigOutputVectorCustom", "[config]") {
std::vector<int> v;
app.add_option("--vector", v);
@@ -1770,10 +1768,10 @@ TEST_F(TApp, ConfigOutputVectorCustom) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("vector:{1; 2; 3}\n", str);
+ CHECK(str == "vector:{1; 2; 3}\n");
}
-TEST_F(TApp, TomlOutputFlag) {
+TEST_CASE_METHOD(TApp, "TomlOutputFlag", "[config]") {
int v{0}, q{0};
app.add_option("--simple", v);
@@ -1786,16 +1784,16 @@ TEST_F(TApp, TomlOutputFlag) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=3"));
- EXPECT_THAT(str, Not(HasSubstr("nothing")));
- EXPECT_THAT(str, HasSubstr("onething=true"));
- EXPECT_THAT(str, HasSubstr("something=[true, true]"));
+ CHECK_THAT(str, Contains("simple=3"));
+ CHECK_THAT(str, !Contains("nothing"));
+ CHECK_THAT(str, Contains("onething=true"));
+ CHECK_THAT(str, Contains("something=[true, true]"));
str = app.config_to_str(true);
- EXPECT_THAT(str, HasSubstr("nothing"));
+ CHECK_THAT(str, Contains("nothing"));
}
-TEST_F(TApp, TomlOutputSet) {
+TEST_CASE_METHOD(TApp, "TomlOutputSet", "[config]") {
int v{0};
app.add_option("--simple", v)->check(CLI::IsMember({1, 2, 3}));
@@ -1805,10 +1803,10 @@ TEST_F(TApp, TomlOutputSet) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=2"));
+ CHECK_THAT(str, Contains("simple=2"));
}
-TEST_F(TApp, TomlOutputDefault) {
+TEST_CASE_METHOD(TApp, "TomlOutputDefault", "[config]") {
int v{7};
app.add_option("--simple", v, "", true);
@@ -1816,13 +1814,13 @@ TEST_F(TApp, TomlOutputDefault) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, Not(HasSubstr("simple=7")));
+ CHECK_THAT(str, !Contains("simple=7"));
str = app.config_to_str(true);
- EXPECT_THAT(str, HasSubstr("simple=7"));
+ CHECK_THAT(str, Contains("simple=7"));
}
-TEST_F(TApp, TomlOutputSubcom) {
+TEST_CASE_METHOD(TApp, "TomlOutputSubcom", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other");
@@ -1832,11 +1830,11 @@ TEST_F(TApp, TomlOutputSubcom) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("other.newer=true"));
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("other.newer=true"));
}
-TEST_F(TApp, TomlOutputSubcomConfigurable) {
+TEST_CASE_METHOD(TApp, "TomlOutputSubcomConfigurable", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other")->configurable();
@@ -1846,13 +1844,13 @@ TEST_F(TApp, TomlOutputSubcomConfigurable) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("[other]"));
- EXPECT_THAT(str, HasSubstr("newer=true"));
- EXPECT_EQ(str.find("other.newer=true"), std::string::npos);
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("[other]"));
+ CHECK_THAT(str, Contains("newer=true"));
+ CHECK(std::string::npos == str.find("other.newer=true"));
}
-TEST_F(TApp, TomlOutputSubsubcom) {
+TEST_CASE_METHOD(TApp, "TomlOutputSubsubcom", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other");
@@ -1864,12 +1862,12 @@ TEST_F(TApp, TomlOutputSubsubcom) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("other.newer=true"));
- EXPECT_THAT(str, HasSubstr("other.sub2.newest=true"));
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("other.newer=true"));
+ CHECK_THAT(str, Contains("other.sub2.newest=true"));
}
-TEST_F(TApp, TomlOutputSubsubcomConfigurable) {
+TEST_CASE_METHOD(TApp, "TomlOutputSubsubcomConfigurable", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other")->configurable();
@@ -1882,15 +1880,15 @@ TEST_F(TApp, TomlOutputSubsubcomConfigurable) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("[other]"));
- EXPECT_THAT(str, HasSubstr("newer=true"));
- EXPECT_THAT(str, HasSubstr("[other.sub2]"));
- EXPECT_THAT(str, HasSubstr("newest=true"));
- EXPECT_EQ(str.find("sub2.newest=true"), std::string::npos);
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("[other]"));
+ CHECK_THAT(str, Contains("newer=true"));
+ CHECK_THAT(str, Contains("[other.sub2]"));
+ CHECK_THAT(str, Contains("newest=true"));
+ CHECK(std::string::npos == str.find("sub2.newest=true"));
}
-TEST_F(TApp, TomlOutputSubsubcomConfigurableDeep) {
+TEST_CASE_METHOD(TApp, "TomlOutputSubsubcomConfigurableDeep", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other")->configurable();
@@ -1907,13 +1905,13 @@ TEST_F(TApp, TomlOutputSubsubcomConfigurableDeep) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("[other.sub2.sub-level2.sub-level3]"));
- EXPECT_THAT(str, HasSubstr("absolute_newest=true"));
- EXPECT_EQ(str.find(".absolute_newest=true"), std::string::npos);
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("[other.sub2.sub-level2.sub-level3]"));
+ CHECK_THAT(str, Contains("absolute_newest=true"));
+ CHECK(std::string::npos == str.find(".absolute_newest=true"));
}
-TEST_F(TApp, TomlOutputQuoted) {
+TEST_CASE_METHOD(TApp, "TomlOutputQuoted", "[config]") {
std::string val1;
app.add_option("--val1", val1);
@@ -1925,15 +1923,15 @@ TEST_F(TApp, TomlOutputQuoted) {
run();
- EXPECT_EQ("I am a string", val1);
- EXPECT_EQ("I am a \"confusing\" string", val2);
+ CHECK(val1 == "I am a string");
+ CHECK(val2 == "I am a \"confusing\" string");
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("val1=\"I am a string\""));
- EXPECT_THAT(str, HasSubstr("val2='I am a \"confusing\" string'"));
+ CHECK_THAT(str, Contains("val1=\"I am a string\""));
+ CHECK_THAT(str, Contains("val2='I am a \"confusing\" string'"));
}
-TEST_F(TApp, DefaultsTomlOutputQuoted) {
+TEST_CASE_METHOD(TApp, "DefaultsTomlOutputQuoted", "[config]") {
std::string val1{"I am a string"};
app.add_option("--val1", val1, "", true);
@@ -1944,18 +1942,18 @@ TEST_F(TApp, DefaultsTomlOutputQuoted) {
run();
std::string str = app.config_to_str(true);
- EXPECT_THAT(str, HasSubstr("val1=\"I am a string\""));
- EXPECT_THAT(str, HasSubstr("val2='I am a \"confusing\" string'"));
+ CHECK_THAT(str, Contains("val1=\"I am a string\""));
+ CHECK_THAT(str, Contains("val2='I am a \"confusing\" string'"));
}
// #298
-TEST_F(TApp, StopReadingConfigOnClear) {
+TEST_CASE_METHOD(TApp, "StopReadingConfigOnClear", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini);
auto ptr = app.set_config(); // Should *not* read config file
- EXPECT_EQ(ptr, nullptr);
+ CHECK(nullptr == ptr);
{
std::ofstream out{tmpini};
@@ -1967,10 +1965,10 @@ TEST_F(TApp, StopReadingConfigOnClear) {
run();
- EXPECT_EQ(volume, 0);
+ CHECK(0 == volume);
}
-TEST_F(TApp, ConfigWriteReadWrite) {
+TEST_CASE_METHOD(TApp, "ConfigWriteReadWrite", "[config]") {
TempFile tmpini{"TestIniTmp.ini"};
@@ -1989,12 +1987,12 @@ TEST_F(TApp, ConfigWriteReadWrite) {
std::string config2 = app.config_to_str(true, true);
- EXPECT_EQ(config1, config2);
+ CHECK(config2 == config1);
}
/////// INI output tests
-TEST_F(TApp, IniOutputSimple) {
+TEST_CASE_METHOD(TApp, "IniOutputSimple", "[config]") {
int v{0};
app.add_option("--simple", v);
@@ -2004,10 +2002,10 @@ TEST_F(TApp, IniOutputSimple) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("simple=3\n", str);
+ CHECK(str == "simple=3\n");
}
-TEST_F(TApp, IniOutputNoConfigurable) {
+TEST_CASE_METHOD(TApp, "IniOutputNoConfigurable", "[config]") {
int v1{0}, v2{0};
app.add_option("--simple", v1);
@@ -2018,10 +2016,10 @@ TEST_F(TApp, IniOutputNoConfigurable) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("simple=3\n", str);
+ CHECK(str == "simple=3\n");
}
-TEST_F(TApp, IniOutputShortSingleDescription) {
+TEST_CASE_METHOD(TApp, "IniOutputShortSingleDescription", "[config]") {
std::string flag = "some_flag";
const std::string description = "Some short description.";
app.add_flag("--" + flag, description);
@@ -2029,10 +2027,10 @@ TEST_F(TApp, IniOutputShortSingleDescription) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("; " + description + "\n" + flag + "=false\n"));
+ CHECK_THAT(str, Contains("; " + description + "\n" + flag + "=false\n"));
}
-TEST_F(TApp, IniOutputShortDoubleDescription) {
+TEST_CASE_METHOD(TApp, "IniOutputShortDoubleDescription", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
const std::string description1 = "First description.";
@@ -2043,11 +2041,11 @@ TEST_F(TApp, IniOutputShortDoubleDescription) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(
- str, HasSubstr("; " + description1 + "\n" + flag1 + "=false\n\n; " + description2 + "\n" + flag2 + "=false\n"));
+ std::string ans = "; " + description1 + "\n" + flag1 + "=false\n\n; " + description2 + "\n" + flag2 + "=false\n";
+ CHECK_THAT(str, Contains(ans));
}
-TEST_F(TApp, IniOutputGroups) {
+TEST_CASE_METHOD(TApp, "IniOutputGroups", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
const std::string description1 = "First description.";
@@ -2058,11 +2056,11 @@ TEST_F(TApp, IniOutputGroups) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("group1"));
- EXPECT_THAT(str, HasSubstr("group2"));
+ CHECK_THAT(str, Contains("group1"));
+ CHECK_THAT(str, Contains("group2"));
}
-TEST_F(TApp, IniOutputHiddenOptions) {
+TEST_CASE_METHOD(TApp, "IniOutputHiddenOptions", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
double val{12.7};
@@ -2075,18 +2073,18 @@ TEST_F(TApp, IniOutputHiddenOptions) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("group1"));
- EXPECT_THAT(str, HasSubstr("group2"));
- EXPECT_THAT(str, HasSubstr("dval=12.7"));
+ CHECK_THAT(str, Contains("group1"));
+ CHECK_THAT(str, Contains("group2"));
+ CHECK_THAT(str, Contains("dval=12.7"));
auto loc = str.find("dval=12.7");
auto locg1 = str.find("group1");
- EXPECT_GT(locg1, loc);
+ CHECK(loc < locg1);
// make sure it doesn't come twice
loc = str.find("dval=12.7", loc + 4);
- EXPECT_EQ(loc, std::string::npos);
+ CHECK(std::string::npos == loc);
}
-TEST_F(TApp, IniOutputMultiLineDescription) {
+TEST_CASE_METHOD(TApp, "IniOutputMultiLineDescription", "[config]") {
std::string flag = "some_flag";
const std::string description = "Some short description.\nThat has lines.";
app.add_flag("--" + flag, description);
@@ -2094,12 +2092,12 @@ TEST_F(TApp, IniOutputMultiLineDescription) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("; Some short description.\n"));
- EXPECT_THAT(str, HasSubstr("; That has lines.\n"));
- EXPECT_THAT(str, HasSubstr(flag + "=false\n"));
+ CHECK_THAT(str, Contains("; Some short description.\n"));
+ CHECK_THAT(str, Contains("; That has lines.\n"));
+ CHECK_THAT(str, Contains(flag + "=false\n"));
}
-TEST_F(TApp, IniOutputOptionGroup) {
+TEST_CASE_METHOD(TApp, "IniOutputOptionGroup", "[config]") {
std::string flag1 = "flagnr1";
std::string flag2 = "flagnr2";
double val{12.7};
@@ -2113,22 +2111,22 @@ TEST_F(TApp, IniOutputOptionGroup) {
run();
std::string str = app.config_to_str(true, true);
- EXPECT_THAT(str, HasSubstr("group1"));
- EXPECT_THAT(str, HasSubstr("group2"));
- EXPECT_THAT(str, HasSubstr("dval=12.7"));
- EXPECT_THAT(str, HasSubstr("group3"));
- EXPECT_THAT(str, HasSubstr("g3 desc"));
+ CHECK_THAT(str, Contains("group1"));
+ CHECK_THAT(str, Contains("group2"));
+ CHECK_THAT(str, Contains("dval=12.7"));
+ CHECK_THAT(str, Contains("group3"));
+ CHECK_THAT(str, Contains("g3 desc"));
auto loc = str.find("dval=12.7");
auto locg1 = str.find("group1");
auto locg3 = str.find("group3");
- EXPECT_LT(locg1, loc);
+ CHECK(loc > locg1);
// make sure it doesn't come twice
loc = str.find("dval=12.7", loc + 4);
- EXPECT_EQ(loc, std::string::npos);
- EXPECT_GT(locg3, locg1);
+ CHECK(std::string::npos == loc);
+ CHECK(locg1 < locg3);
}
-TEST_F(TApp, IniOutputVector) {
+TEST_CASE_METHOD(TApp, "IniOutputVector", "[config]") {
std::vector<int> v;
app.add_option("--vector", v);
@@ -2138,10 +2136,10 @@ TEST_F(TApp, IniOutputVector) {
run();
std::string str = app.config_to_str();
- EXPECT_EQ("vector=1 2 3\n", str);
+ CHECK(str == "vector=1 2 3\n");
}
-TEST_F(TApp, IniOutputFlag) {
+TEST_CASE_METHOD(TApp, "IniOutputFlag", "[config]") {
int v{0}, q{0};
app.add_option("--simple", v);
@@ -2154,16 +2152,16 @@ TEST_F(TApp, IniOutputFlag) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=3"));
- EXPECT_THAT(str, Not(HasSubstr("nothing")));
- EXPECT_THAT(str, HasSubstr("onething=true"));
- EXPECT_THAT(str, HasSubstr("something=true true"));
+ CHECK_THAT(str, Contains("simple=3"));
+ CHECK_THAT(str, !Contains("nothing"));
+ CHECK_THAT(str, Contains("onething=true"));
+ CHECK_THAT(str, Contains("something=true true"));
str = app.config_to_str(true);
- EXPECT_THAT(str, HasSubstr("nothing"));
+ CHECK_THAT(str, Contains("nothing"));
}
-TEST_F(TApp, IniOutputSet) {
+TEST_CASE_METHOD(TApp, "IniOutputSet", "[config]") {
int v{0};
app.add_option("--simple", v)->check(CLI::IsMember({1, 2, 3}));
@@ -2173,10 +2171,10 @@ TEST_F(TApp, IniOutputSet) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=2"));
+ CHECK_THAT(str, Contains("simple=2"));
}
-TEST_F(TApp, IniOutputDefault) {
+TEST_CASE_METHOD(TApp, "IniOutputDefault", "[config]") {
int v{7};
app.add_option("--simple", v, "", true);
@@ -2184,13 +2182,13 @@ TEST_F(TApp, IniOutputDefault) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, Not(HasSubstr("simple=7")));
+ CHECK_THAT(str, !Contains("simple=7"));
str = app.config_to_str(true);
- EXPECT_THAT(str, HasSubstr("simple=7"));
+ CHECK_THAT(str, Contains("simple=7"));
}
-TEST_F(TApp, IniOutputSubcom) {
+TEST_CASE_METHOD(TApp, "IniOutputSubcom", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other");
@@ -2200,11 +2198,11 @@ TEST_F(TApp, IniOutputSubcom) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("other.newer=true"));
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("other.newer=true"));
}
-TEST_F(TApp, IniOutputSubcomConfigurable) {
+TEST_CASE_METHOD(TApp, "IniOutputSubcomConfigurable", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other")->configurable();
@@ -2214,13 +2212,13 @@ TEST_F(TApp, IniOutputSubcomConfigurable) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("[other]"));
- EXPECT_THAT(str, HasSubstr("newer=true"));
- EXPECT_EQ(str.find("other.newer=true"), std::string::npos);
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("[other]"));
+ CHECK_THAT(str, Contains("newer=true"));
+ CHECK(std::string::npos == str.find("other.newer=true"));
}
-TEST_F(TApp, IniOutputSubsubcom) {
+TEST_CASE_METHOD(TApp, "IniOutputSubsubcom", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other");
@@ -2232,12 +2230,12 @@ TEST_F(TApp, IniOutputSubsubcom) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("other.newer=true"));
- EXPECT_THAT(str, HasSubstr("other.sub2.newest=true"));
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("other.newer=true"));
+ CHECK_THAT(str, Contains("other.sub2.newest=true"));
}
-TEST_F(TApp, IniOutputSubsubcomConfigurable) {
+TEST_CASE_METHOD(TApp, "IniOutputSubsubcomConfigurable", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other")->configurable();
@@ -2250,15 +2248,15 @@ TEST_F(TApp, IniOutputSubsubcomConfigurable) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("[other]"));
- EXPECT_THAT(str, HasSubstr("newer=true"));
- EXPECT_THAT(str, HasSubstr("[other.sub2]"));
- EXPECT_THAT(str, HasSubstr("newest=true"));
- EXPECT_EQ(str.find("sub2.newest=true"), std::string::npos);
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("[other]"));
+ CHECK_THAT(str, Contains("newer=true"));
+ CHECK_THAT(str, Contains("[other.sub2]"));
+ CHECK_THAT(str, Contains("newest=true"));
+ CHECK(std::string::npos == str.find("sub2.newest=true"));
}
-TEST_F(TApp, IniOutputSubsubcomConfigurableDeep) {
+TEST_CASE_METHOD(TApp, "IniOutputSubsubcomConfigurableDeep", "[config]") {
app.add_flag("--simple");
auto subcom = app.add_subcommand("other")->configurable();
@@ -2275,13 +2273,13 @@ TEST_F(TApp, IniOutputSubsubcomConfigurableDeep) {
run();
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("simple=true"));
- EXPECT_THAT(str, HasSubstr("[other.sub2.sub-level2.sub-level3]"));
- EXPECT_THAT(str, HasSubstr("absolute_newest=true"));
- EXPECT_EQ(str.find(".absolute_newest=true"), std::string::npos);
+ CHECK_THAT(str, Contains("simple=true"));
+ CHECK_THAT(str, Contains("[other.sub2.sub-level2.sub-level3]"));
+ CHECK_THAT(str, Contains("absolute_newest=true"));
+ CHECK(std::string::npos == str.find(".absolute_newest=true"));
}
-TEST_F(TApp, IniOutputQuoted) {
+TEST_CASE_METHOD(TApp, "IniOutputQuoted", "[config]") {
std::string val1;
app.add_option("--val1", val1);
@@ -2293,15 +2291,15 @@ TEST_F(TApp, IniOutputQuoted) {
run();
- EXPECT_EQ("I am a string", val1);
- EXPECT_EQ("I am a \"confusing\" string", val2);
+ CHECK(val1 == "I am a string");
+ CHECK(val2 == "I am a \"confusing\" string");
std::string str = app.config_to_str();
- EXPECT_THAT(str, HasSubstr("val1=\"I am a string\""));
- EXPECT_THAT(str, HasSubstr("val2='I am a \"confusing\" string'"));
+ CHECK_THAT(str, Contains("val1=\"I am a string\""));
+ CHECK_THAT(str, Contains("val2='I am a \"confusing\" string'"));
}
-TEST_F(TApp, DefaultsIniOutputQuoted) {
+TEST_CASE_METHOD(TApp, "DefaultsIniOutputQuoted", "[config]") {
std::string val1{"I am a string"};
app.add_option("--val1", val1, "", true);
@@ -2312,6 +2310,6 @@ TEST_F(TApp, DefaultsIniOutputQuoted) {
run();
std::string str = app.config_to_str(true);
- EXPECT_THAT(str, HasSubstr("val1=\"I am a string\""));
- EXPECT_THAT(str, HasSubstr("val2='I am a \"confusing\" string'"));
+ CHECK_THAT(str, Contains("val1=\"I am a string\""));
+ CHECK_THAT(str, Contains("val2='I am a \"confusing\" string'"));
}
diff --git a/packages/CLI11/tests/CreationTest.cpp b/packages/CLI11/tests/CreationTest.cpp
index 648c4aebba3de45e1e4e85232eafdd54e4c2ce0c..2a70f70d419552e96e13e0cf3a3c6f524a64ce68 100644
--- a/packages/CLI11/tests/CreationTest.cpp
+++ b/packages/CLI11/tests/CreationTest.cpp
@@ -7,221 +7,224 @@
#include "app_helper.hpp"
#include <cstdlib>
-TEST_F(TApp, AddingExistingShort) {
+TEST_CASE_METHOD(TApp, "AddingExistingShort", "[creation]") {
CLI::Option *opt = app.add_flag("-c,--count");
- EXPECT_EQ(opt->get_lnames(), std::vector<std::string>({"count"}));
- EXPECT_EQ(opt->get_snames(), std::vector<std::string>({"c"}));
+ CHECK(std::vector<std::string>({"count"}) == opt->get_lnames());
+ CHECK(std::vector<std::string>({"c"}) == opt->get_snames());
- EXPECT_THROW(app.add_flag("--cat,-c"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_flag("--cat,-c"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingLong) {
+TEST_CASE_METHOD(TApp, "AddingExistingLong", "[creation]") {
app.add_flag("-q,--count");
- EXPECT_THROW(app.add_flag("--count,-c"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_flag("--count,-c"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingShortNoCase) {
+TEST_CASE_METHOD(TApp, "AddingExistingShortNoCase", "[creation]") {
app.add_flag("-C,--count")->ignore_case();
- EXPECT_THROW(app.add_flag("--cat,-c"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_flag("--cat,-c"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingLongNoCase) {
+TEST_CASE_METHOD(TApp, "AddingExistingLongNoCase", "[creation]") {
app.add_flag("-q,--count")->ignore_case();
- EXPECT_THROW(app.add_flag("--Count,-c"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_flag("--Count,-c"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingNoCaseReversed) {
+TEST_CASE_METHOD(TApp, "AddingExistingNoCaseReversed", "[creation]") {
app.add_flag("-c,--count")->ignore_case();
- EXPECT_THROW(app.add_flag("--cat,-C"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_flag("--cat,-C"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingWithCase) {
+TEST_CASE_METHOD(TApp, "AddingExistingWithCase", "[creation]") {
app.add_flag("-c,--count");
- EXPECT_NO_THROW(app.add_flag("--Cat,-C"));
+ CHECK_NOTHROW(app.add_flag("--Cat,-C"));
}
-TEST_F(TApp, AddingExistingWithCaseAfter) {
+TEST_CASE_METHOD(TApp, "AddingExistingWithCaseAfter", "[creation]") {
auto count = app.add_flag("-c,--count");
app.add_flag("--Cat,-C");
- EXPECT_THROW(count->ignore_case(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(count->ignore_case(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingWithCaseAfter2) {
+TEST_CASE_METHOD(TApp, "AddingExistingWithCaseAfter2", "[creation]") {
app.add_flag("-c,--count");
auto cat = app.add_flag("--Cat,-C");
- EXPECT_THROW(cat->ignore_case(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(cat->ignore_case(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingWithUnderscoreAfter) {
+TEST_CASE_METHOD(TApp, "AddingExistingWithUnderscoreAfter", "[creation]") {
auto count = app.add_flag("--underscore");
app.add_flag("--under_score");
- EXPECT_THROW(count->ignore_underscore(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(count->ignore_underscore(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingExistingWithUnderscoreAfter2) {
+TEST_CASE_METHOD(TApp, "AddingExistingWithUnderscoreAfter2", "[creation]") {
auto count = app.add_flag("--under_score");
app.add_flag("--underscore");
- EXPECT_THROW(count->ignore_underscore(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(count->ignore_underscore(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, AddingMultipleInfPositionals) {
+TEST_CASE_METHOD(TApp, "AddingMultipleInfPositionals", "[creation]") {
std::vector<std::string> one, two;
app.add_option("one", one);
app.add_option("two", two);
- EXPECT_THROW(run(), CLI::InvalidError);
+ CHECK_THROWS_AS(run(), CLI::InvalidError);
}
-TEST_F(TApp, AddingMultipleInfPositionalsSubcom) {
+TEST_CASE_METHOD(TApp, "AddingMultipleInfPositionalsSubcom", "[creation]") {
std::vector<std::string> one, two;
CLI::App *below = app.add_subcommand("below");
below->add_option("one", one);
below->add_option("two", two);
- EXPECT_THROW(run(), CLI::InvalidError);
+ CHECK_THROWS_AS(run(), CLI::InvalidError);
}
-TEST_F(TApp, MultipleSubcomMatching) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatching", "[creation]") {
app.add_subcommand("first");
app.add_subcommand("second");
app.add_subcommand("Second");
- EXPECT_THROW(app.add_subcommand("first"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_subcommand("first"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, RecoverSubcommands) {
+TEST_CASE_METHOD(TApp, "RecoverSubcommands", "[creation]") {
CLI::App *app1 = app.add_subcommand("app1");
CLI::App *app2 = app.add_subcommand("app2");
CLI::App *app3 = app.add_subcommand("app3");
CLI::App *app4 = app.add_subcommand("app4");
- EXPECT_EQ(app.get_subcommands({}), std::vector<CLI::App *>({app1, app2, app3, app4}));
+ CHECK(std::vector<CLI::App *>({app1, app2, app3, app4}) == app.get_subcommands({}));
}
-TEST_F(TApp, MultipleSubcomMatchingWithCase) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithCase", "[creation]") {
app.add_subcommand("first")->ignore_case();
- EXPECT_THROW(app.add_subcommand("fIrst"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_subcommand("fIrst"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithCaseFirst) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithCaseFirst", "[creation]") {
app.ignore_case();
app.add_subcommand("first");
- EXPECT_THROW(app.add_subcommand("fIrst"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_subcommand("fIrst"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithUnderscore) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithUnderscore", "[creation]") {
app.add_subcommand("first_option")->ignore_underscore();
- EXPECT_THROW(app.add_subcommand("firstoption"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_subcommand("firstoption"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithUnderscoreFirst) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithUnderscoreFirst", "[creation]") {
app.ignore_underscore();
app.add_subcommand("first_option");
- EXPECT_THROW(app.add_subcommand("firstoption"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(app.add_subcommand("firstoption"), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithCaseInplace) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithCaseInplace", "[creation]") {
app.add_subcommand("first");
auto first = app.add_subcommand("fIrst");
- EXPECT_THROW(first->ignore_case(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(first->ignore_case(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithCaseInplace2) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithCaseInplace2", "[creation]") {
auto first = app.add_subcommand("first");
app.add_subcommand("fIrst");
- EXPECT_THROW(first->ignore_case(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(first->ignore_case(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithUnderscoreInplace) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithUnderscoreInplace", "[creation]") {
app.add_subcommand("first_option");
auto first = app.add_subcommand("firstoption");
- EXPECT_THROW(first->ignore_underscore(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(first->ignore_underscore(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomMatchingWithUnderscoreInplace2) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomMatchingWithUnderscoreInplace2", "[creation]") {
auto first = app.add_subcommand("firstoption");
app.add_subcommand("first_option");
- EXPECT_THROW(first->ignore_underscore(), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(first->ignore_underscore(), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, MultipleSubcomNoMatchingInplace2) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomNoMatchingInplace2", "[creation]") {
auto first = app.add_subcommand("first");
auto second = app.add_subcommand("second");
- EXPECT_NO_THROW(first->ignore_case());
- EXPECT_NO_THROW(second->ignore_case());
+ CHECK_NOTHROW(first->ignore_case());
+ CHECK_NOTHROW(second->ignore_case());
}
-TEST_F(TApp, MultipleSubcomNoMatchingInplaceUnderscore2) {
+TEST_CASE_METHOD(TApp, "MultipleSubcomNoMatchingInplaceUnderscore2", "[creation]") {
auto first = app.add_subcommand("first_option");
auto second = app.add_subcommand("second_option");
- EXPECT_NO_THROW(first->ignore_underscore());
- EXPECT_NO_THROW(second->ignore_underscore());
+ CHECK_NOTHROW(first->ignore_underscore());
+ CHECK_NOTHROW(second->ignore_underscore());
}
-TEST_F(TApp, IncorrectConstructionFlagPositional1) { EXPECT_THROW(app.add_flag("cat"), CLI::IncorrectConstruction); }
+TEST_CASE_METHOD(TApp, "IncorrectConstructionFlagPositional1", "[creation]") {
+ // This wants to be one line with clang-format
+ CHECK_THROWS_AS(app.add_flag("cat"), CLI::IncorrectConstruction);
+}
-TEST_F(TApp, IncorrectConstructionFlagPositional2) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionFlagPositional2", "[creation]") {
int x{0};
- EXPECT_THROW(app.add_flag("cat", x), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag("cat", x), CLI::IncorrectConstruction);
}
-TEST_F(TApp, IncorrectConstructionFlagPositional3) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionFlagPositional3", "[creation]") {
bool x{false};
- EXPECT_THROW(app.add_flag("cat", x), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag("cat", x), CLI::IncorrectConstruction);
}
-TEST_F(TApp, IncorrectConstructionNeedsCannotFind) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionNeedsCannotFind", "[creation]") {
auto cat = app.add_flag("--cat");
- EXPECT_THROW(cat->needs("--nothing"), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(cat->needs("--nothing"), CLI::IncorrectConstruction);
}
-TEST_F(TApp, IncorrectConstructionExcludesCannotFind) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionExcludesCannotFind", "[creation]") {
auto cat = app.add_flag("--cat");
- EXPECT_THROW(cat->excludes("--nothing"), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(cat->excludes("--nothing"), CLI::IncorrectConstruction);
}
-TEST_F(TApp, IncorrectConstructionDuplicateNeeds) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionDuplicateNeeds", "[creation]") {
auto cat = app.add_flag("--cat");
auto other = app.add_flag("--other");
- ASSERT_NO_THROW(cat->needs(other));
+ REQUIRE_NOTHROW(cat->needs(other));
// duplicated needs is redundant but not an error
- EXPECT_NO_THROW(cat->needs(other));
+ CHECK_NOTHROW(cat->needs(other));
}
-TEST_F(TApp, IncorrectConstructionDuplicateNeedsTxt) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionDuplicateNeedsTxt", "[creation]") {
auto cat = app.add_flag("--cat");
app.add_flag("--other");
- ASSERT_NO_THROW(cat->needs("--other"));
+ REQUIRE_NOTHROW(cat->needs("--other"));
// duplicate needs is redundant but not an error
- EXPECT_NO_THROW(cat->needs("--other"));
+ CHECK_NOTHROW(cat->needs("--other"));
}
// Now allowed
-TEST_F(TApp, CorrectConstructionDuplicateExcludes) {
+TEST_CASE_METHOD(TApp, "CorrectConstructionDuplicateExcludes", "[creation]") {
auto cat = app.add_flag("--cat");
auto other = app.add_flag("--other");
- ASSERT_NO_THROW(cat->excludes(other));
- ASSERT_NO_THROW(other->excludes(cat));
+ REQUIRE_NOTHROW(cat->excludes(other));
+ REQUIRE_NOTHROW(other->excludes(cat));
}
// Now allowed
-TEST_F(TApp, CorrectConstructionDuplicateExcludesTxt) {
+TEST_CASE_METHOD(TApp, "CorrectConstructionDuplicateExcludesTxt", "[creation]") {
auto cat = app.add_flag("--cat");
auto other = app.add_flag("--other");
- ASSERT_NO_THROW(cat->excludes("--other"));
- ASSERT_NO_THROW(other->excludes("--cat"));
+ REQUIRE_NOTHROW(cat->excludes("--other"));
+ REQUIRE_NOTHROW(other->excludes("--cat"));
}
-TEST_F(TApp, CheckName) {
+TEST_CASE_METHOD(TApp, "CheckName", "[creation]") {
auto long1 = app.add_flag("--long1");
auto long2 = app.add_flag("--Long2");
auto short1 = app.add_flag("-a");
@@ -230,26 +233,26 @@ TEST_F(TApp, CheckName) {
auto pos1 = app.add_option("pos1", x);
auto pos2 = app.add_option("pOs2", y);
- EXPECT_TRUE(long1->check_name("--long1"));
- EXPECT_FALSE(long1->check_name("--lonG1"));
+ CHECK(long1->check_name("--long1"));
+ CHECK(!long1->check_name("--lonG1"));
- EXPECT_TRUE(long2->check_name("--Long2"));
- EXPECT_FALSE(long2->check_name("--long2"));
+ CHECK(long2->check_name("--Long2"));
+ CHECK(!long2->check_name("--long2"));
- EXPECT_TRUE(short1->check_name("-a"));
- EXPECT_FALSE(short1->check_name("-A"));
+ CHECK(short1->check_name("-a"));
+ CHECK(!short1->check_name("-A"));
- EXPECT_TRUE(short2->check_name("-B"));
- EXPECT_FALSE(short2->check_name("-b"));
+ CHECK(short2->check_name("-B"));
+ CHECK(!short2->check_name("-b"));
- EXPECT_TRUE(pos1->check_name("pos1"));
- EXPECT_FALSE(pos1->check_name("poS1"));
+ CHECK(pos1->check_name("pos1"));
+ CHECK(!pos1->check_name("poS1"));
- EXPECT_TRUE(pos2->check_name("pOs2"));
- EXPECT_FALSE(pos2->check_name("pos2"));
+ CHECK(pos2->check_name("pOs2"));
+ CHECK(!pos2->check_name("pos2"));
}
-TEST_F(TApp, CheckNameNoCase) {
+TEST_CASE_METHOD(TApp, "CheckNameNoCase", "[creation]") {
auto long1 = app.add_flag("--long1")->ignore_case();
auto long2 = app.add_flag("--Long2")->ignore_case();
auto short1 = app.add_flag("-a")->ignore_case();
@@ -258,26 +261,26 @@ TEST_F(TApp, CheckNameNoCase) {
auto pos1 = app.add_option("pos1", x)->ignore_case();
auto pos2 = app.add_option("pOs2", y)->ignore_case();
- EXPECT_TRUE(long1->check_name("--long1"));
- EXPECT_TRUE(long1->check_name("--lonG1"));
+ CHECK(long1->check_name("--long1"));
+ CHECK(long1->check_name("--lonG1"));
- EXPECT_TRUE(long2->check_name("--Long2"));
- EXPECT_TRUE(long2->check_name("--long2"));
+ CHECK(long2->check_name("--Long2"));
+ CHECK(long2->check_name("--long2"));
- EXPECT_TRUE(short1->check_name("-a"));
- EXPECT_TRUE(short1->check_name("-A"));
+ CHECK(short1->check_name("-a"));
+ CHECK(short1->check_name("-A"));
- EXPECT_TRUE(short2->check_name("-B"));
- EXPECT_TRUE(short2->check_name("-b"));
+ CHECK(short2->check_name("-B"));
+ CHECK(short2->check_name("-b"));
- EXPECT_TRUE(pos1->check_name("pos1"));
- EXPECT_TRUE(pos1->check_name("poS1"));
+ CHECK(pos1->check_name("pos1"));
+ CHECK(pos1->check_name("poS1"));
- EXPECT_TRUE(pos2->check_name("pOs2"));
- EXPECT_TRUE(pos2->check_name("pos2"));
+ CHECK(pos2->check_name("pOs2"));
+ CHECK(pos2->check_name("pos2"));
}
-TEST_F(TApp, CheckNameNoUnderscore) {
+TEST_CASE_METHOD(TApp, "CheckNameNoUnderscore", "[creation]") {
auto long1 = app.add_flag("--longoption1")->ignore_underscore();
auto long2 = app.add_flag("--long_option2")->ignore_underscore();
@@ -285,30 +288,30 @@ TEST_F(TApp, CheckNameNoUnderscore) {
auto pos1 = app.add_option("pos_option_1", x)->ignore_underscore();
auto pos2 = app.add_option("posoption2", y)->ignore_underscore();
- EXPECT_TRUE(long1->check_name("--long_option1"));
- EXPECT_TRUE(long1->check_name("--longoption_1"));
- EXPECT_TRUE(long1->check_name("--longoption1"));
- EXPECT_TRUE(long1->check_name("--long__opt_ion__1"));
- EXPECT_TRUE(long1->check_name("--__l_o_n_g_o_p_t_i_o_n_1"));
+ CHECK(long1->check_name("--long_option1"));
+ CHECK(long1->check_name("--longoption_1"));
+ CHECK(long1->check_name("--longoption1"));
+ CHECK(long1->check_name("--long__opt_ion__1"));
+ CHECK(long1->check_name("--__l_o_n_g_o_p_t_i_o_n_1"));
- EXPECT_TRUE(long2->check_name("--long_option2"));
- EXPECT_TRUE(long2->check_name("--longoption2"));
- EXPECT_TRUE(long2->check_name("--longoption_2"));
- EXPECT_TRUE(long2->check_name("--long__opt_ion__2"));
- EXPECT_TRUE(long2->check_name("--__l_o_n_go_p_t_i_o_n_2__"));
+ CHECK(long2->check_name("--long_option2"));
+ CHECK(long2->check_name("--longoption2"));
+ CHECK(long2->check_name("--longoption_2"));
+ CHECK(long2->check_name("--long__opt_ion__2"));
+ CHECK(long2->check_name("--__l_o_n_go_p_t_i_o_n_2__"));
- EXPECT_TRUE(pos1->check_name("pos_option1"));
- EXPECT_TRUE(pos1->check_name("pos_option_1"));
- EXPECT_TRUE(pos1->check_name("pos_o_p_t_i_on_1"));
- EXPECT_TRUE(pos1->check_name("posoption1"));
+ CHECK(pos1->check_name("pos_option1"));
+ CHECK(pos1->check_name("pos_option_1"));
+ CHECK(pos1->check_name("pos_o_p_t_i_on_1"));
+ CHECK(pos1->check_name("posoption1"));
- EXPECT_TRUE(pos2->check_name("pos_option2"));
- EXPECT_TRUE(pos2->check_name("pos_option_2"));
- EXPECT_TRUE(pos2->check_name("pos_o_p_t_i_on_2"));
- EXPECT_TRUE(pos2->check_name("posoption2"));
+ CHECK(pos2->check_name("pos_option2"));
+ CHECK(pos2->check_name("pos_option_2"));
+ CHECK(pos2->check_name("pos_o_p_t_i_on_2"));
+ CHECK(pos2->check_name("posoption2"));
}
-TEST_F(TApp, CheckNameNoCaseNoUnderscore) {
+TEST_CASE_METHOD(TApp, "CheckNameNoCaseNoUnderscore", "[creation]") {
auto long1 = app.add_flag("--LongoptioN1")->ignore_underscore()->ignore_case();
auto long2 = app.add_flag("--long_Option2")->ignore_case()->ignore_underscore();
@@ -316,85 +319,85 @@ TEST_F(TApp, CheckNameNoCaseNoUnderscore) {
auto pos1 = app.add_option("pos_Option_1", x)->ignore_underscore()->ignore_case();
auto pos2 = app.add_option("posOption2", y)->ignore_case()->ignore_underscore();
- EXPECT_TRUE(long1->check_name("--Long_Option1"));
- EXPECT_TRUE(long1->check_name("--lONgoption_1"));
- EXPECT_TRUE(long1->check_name("--LongOption1"));
- EXPECT_TRUE(long1->check_name("--long__Opt_ion__1"));
- EXPECT_TRUE(long1->check_name("--__l_o_N_g_o_P_t_i_O_n_1"));
+ CHECK(long1->check_name("--Long_Option1"));
+ CHECK(long1->check_name("--lONgoption_1"));
+ CHECK(long1->check_name("--LongOption1"));
+ CHECK(long1->check_name("--long__Opt_ion__1"));
+ CHECK(long1->check_name("--__l_o_N_g_o_P_t_i_O_n_1"));
- EXPECT_TRUE(long2->check_name("--long_Option2"));
- EXPECT_TRUE(long2->check_name("--LongOption2"));
- EXPECT_TRUE(long2->check_name("--longOPTION_2"));
- EXPECT_TRUE(long2->check_name("--long__OPT_ion__2"));
- EXPECT_TRUE(long2->check_name("--__l_o_n_GO_p_t_i_o_n_2__"));
+ CHECK(long2->check_name("--long_Option2"));
+ CHECK(long2->check_name("--LongOption2"));
+ CHECK(long2->check_name("--longOPTION_2"));
+ CHECK(long2->check_name("--long__OPT_ion__2"));
+ CHECK(long2->check_name("--__l_o_n_GO_p_t_i_o_n_2__"));
- EXPECT_TRUE(pos1->check_name("POS_Option1"));
- EXPECT_TRUE(pos1->check_name("pos_option_1"));
- EXPECT_TRUE(pos1->check_name("pos_o_p_t_i_on_1"));
- EXPECT_TRUE(pos1->check_name("posoption1"));
+ CHECK(pos1->check_name("POS_Option1"));
+ CHECK(pos1->check_name("pos_option_1"));
+ CHECK(pos1->check_name("pos_o_p_t_i_on_1"));
+ CHECK(pos1->check_name("posoption1"));
- EXPECT_TRUE(pos2->check_name("pos_option2"));
- EXPECT_TRUE(pos2->check_name("pos_OPTION_2"));
- EXPECT_TRUE(pos2->check_name("poS_o_p_T_I_on_2"));
- EXPECT_TRUE(pos2->check_name("PosOption2"));
+ CHECK(pos2->check_name("pos_option2"));
+ CHECK(pos2->check_name("pos_OPTION_2"));
+ CHECK(pos2->check_name("poS_o_p_T_I_on_2"));
+ CHECK(pos2->check_name("PosOption2"));
}
-TEST_F(TApp, PreSpaces) {
+TEST_CASE_METHOD(TApp, "PreSpaces", "[creation]") {
int x{0};
auto myapp = app.add_option(" -a, --long, other", x);
- EXPECT_TRUE(myapp->check_lname("long"));
- EXPECT_TRUE(myapp->check_sname("a"));
- EXPECT_TRUE(myapp->check_name("other"));
+ CHECK(myapp->check_lname("long"));
+ CHECK(myapp->check_sname("a"));
+ CHECK(myapp->check_name("other"));
}
-TEST_F(TApp, AllSpaces) {
+TEST_CASE_METHOD(TApp, "AllSpaces", "[creation]") {
int x{0};
auto myapp = app.add_option(" -a , --long , other ", x);
- EXPECT_TRUE(myapp->check_lname("long"));
- EXPECT_TRUE(myapp->check_sname("a"));
- EXPECT_TRUE(myapp->check_name("other"));
+ CHECK(myapp->check_lname("long"));
+ CHECK(myapp->check_sname("a"));
+ CHECK(myapp->check_name("other"));
}
-TEST_F(TApp, OptionFromDefaults) {
+TEST_CASE_METHOD(TApp, "OptionFromDefaults", "[creation]") {
app.option_defaults()->required();
// Options should remember defaults
int x{0};
auto opt = app.add_option("--simple", x);
- EXPECT_TRUE(opt->get_required());
+ CHECK(opt->get_required());
// Flags cannot be required
auto flag = app.add_flag("--other");
- EXPECT_FALSE(flag->get_required());
+ CHECK(!flag->get_required());
app.option_defaults()->required(false);
auto opt2 = app.add_option("--simple2", x);
- EXPECT_FALSE(opt2->get_required());
+ CHECK(!opt2->get_required());
app.option_defaults()->required()->ignore_case();
auto opt3 = app.add_option("--simple3", x);
- EXPECT_TRUE(opt3->get_required());
- EXPECT_TRUE(opt3->get_ignore_case());
+ CHECK(opt3->get_required());
+ CHECK(opt3->get_ignore_case());
app.option_defaults()->required()->ignore_underscore();
auto opt4 = app.add_option("--simple4", x);
- EXPECT_TRUE(opt4->get_required());
- EXPECT_TRUE(opt4->get_ignore_underscore());
+ CHECK(opt4->get_required());
+ CHECK(opt4->get_ignore_underscore());
}
-TEST_F(TApp, OptionFromDefaultsSubcommands) {
+TEST_CASE_METHOD(TApp, "OptionFromDefaultsSubcommands", "[creation]") {
// Initial defaults
- EXPECT_FALSE(app.option_defaults()->get_required());
- EXPECT_EQ(app.option_defaults()->get_multi_option_policy(), CLI::MultiOptionPolicy::Throw);
- EXPECT_FALSE(app.option_defaults()->get_ignore_case());
- EXPECT_FALSE(app.option_defaults()->get_ignore_underscore());
- EXPECT_FALSE(app.option_defaults()->get_disable_flag_override());
- EXPECT_TRUE(app.option_defaults()->get_configurable());
- EXPECT_EQ(app.option_defaults()->get_group(), "Options");
+ CHECK(!app.option_defaults()->get_required());
+ CHECK(CLI::MultiOptionPolicy::Throw == app.option_defaults()->get_multi_option_policy());
+ CHECK(!app.option_defaults()->get_ignore_case());
+ CHECK(!app.option_defaults()->get_ignore_underscore());
+ CHECK(!app.option_defaults()->get_disable_flag_override());
+ CHECK(app.option_defaults()->get_configurable());
+ CHECK("Options" == app.option_defaults()->get_group());
app.option_defaults()
->required()
@@ -407,55 +410,55 @@ TEST_F(TApp, OptionFromDefaultsSubcommands) {
auto app2 = app.add_subcommand("app2");
- EXPECT_TRUE(app2->option_defaults()->get_required());
- EXPECT_EQ(app2->option_defaults()->get_multi_option_policy(), CLI::MultiOptionPolicy::TakeLast);
- EXPECT_TRUE(app2->option_defaults()->get_ignore_case());
- EXPECT_TRUE(app2->option_defaults()->get_ignore_underscore());
- EXPECT_FALSE(app2->option_defaults()->get_configurable());
- EXPECT_TRUE(app.option_defaults()->get_disable_flag_override());
- EXPECT_EQ(app2->option_defaults()->get_group(), "Something");
+ CHECK(app2->option_defaults()->get_required());
+ CHECK(CLI::MultiOptionPolicy::TakeLast == app2->option_defaults()->get_multi_option_policy());
+ CHECK(app2->option_defaults()->get_ignore_case());
+ CHECK(app2->option_defaults()->get_ignore_underscore());
+ CHECK(!app2->option_defaults()->get_configurable());
+ CHECK(app.option_defaults()->get_disable_flag_override());
+ CHECK("Something" == app2->option_defaults()->get_group());
}
-TEST_F(TApp, GetNameCheck) {
+TEST_CASE_METHOD(TApp, "GetNameCheck", "[creation]") {
int x{0};
auto a = app.add_flag("--that");
auto b = app.add_flag("-x");
auto c = app.add_option("pos", x);
auto d = app.add_option("one,-o,--other", x);
- EXPECT_EQ(a->get_name(false, true), "--that");
- EXPECT_EQ(b->get_name(false, true), "-x");
- EXPECT_EQ(c->get_name(false, true), "pos");
+ CHECK("--that" == a->get_name(false, true));
+ CHECK("-x" == b->get_name(false, true));
+ CHECK("pos" == c->get_name(false, true));
- EXPECT_EQ(d->get_name(), "--other");
- EXPECT_EQ(d->get_name(false, false), "--other");
- EXPECT_EQ(d->get_name(false, true), "-o,--other");
- EXPECT_EQ(d->get_name(true, true), "one,-o,--other");
- EXPECT_EQ(d->get_name(true, false), "one");
+ CHECK("--other" == d->get_name());
+ CHECK("--other" == d->get_name(false, false));
+ CHECK("-o,--other" == d->get_name(false, true));
+ CHECK("one,-o,--other" == d->get_name(true, true));
+ CHECK("one" == d->get_name(true, false));
}
-TEST_F(TApp, SubcommandDefaults) {
+TEST_CASE_METHOD(TApp, "SubcommandDefaults", "[creation]") {
// allow_extras, prefix_command, ignore_case, fallthrough, group, min/max subcommand, validate_positionals
// Initial defaults
- EXPECT_FALSE(app.get_allow_extras());
- EXPECT_FALSE(app.get_prefix_command());
- EXPECT_FALSE(app.get_immediate_callback());
- EXPECT_FALSE(app.get_ignore_case());
- EXPECT_FALSE(app.get_ignore_underscore());
+ CHECK(!app.get_allow_extras());
+ CHECK(!app.get_prefix_command());
+ CHECK(!app.get_immediate_callback());
+ CHECK(!app.get_ignore_case());
+ CHECK(!app.get_ignore_underscore());
#ifdef _WIN32
- EXPECT_TRUE(app.get_allow_windows_style_options());
+ CHECK(app.get_allow_windows_style_options());
#else
- EXPECT_FALSE(app.get_allow_windows_style_options());
+ CHECK(!app.get_allow_windows_style_options());
#endif
- EXPECT_FALSE(app.get_fallthrough());
- EXPECT_FALSE(app.get_configurable());
- EXPECT_FALSE(app.get_validate_positionals());
+ CHECK(!app.get_fallthrough());
+ CHECK(!app.get_configurable());
+ CHECK(!app.get_validate_positionals());
- EXPECT_EQ(app.get_footer(), "");
- EXPECT_EQ(app.get_group(), "Subcommands");
- EXPECT_EQ(app.get_require_subcommand_min(), 0u);
- EXPECT_EQ(app.get_require_subcommand_max(), 0u);
+ CHECK("" == app.get_footer());
+ CHECK("Subcommands" == app.get_group());
+ CHECK(0u == app.get_require_subcommand_min());
+ CHECK(0u == app.get_require_subcommand_max());
app.allow_extras();
app.prefix_command();
@@ -478,57 +481,57 @@ TEST_F(TApp, SubcommandDefaults) {
auto app2 = app.add_subcommand("app2");
// Initial defaults
- EXPECT_TRUE(app2->get_allow_extras());
- EXPECT_TRUE(app2->get_prefix_command());
- EXPECT_TRUE(app2->get_immediate_callback());
- EXPECT_TRUE(app2->get_ignore_case());
- EXPECT_TRUE(app2->get_ignore_underscore());
+ CHECK(app2->get_allow_extras());
+ CHECK(app2->get_prefix_command());
+ CHECK(app2->get_immediate_callback());
+ CHECK(app2->get_ignore_case());
+ CHECK(app2->get_ignore_underscore());
#ifdef _WIN32
- EXPECT_FALSE(app2->get_allow_windows_style_options());
+ CHECK(!app2->get_allow_windows_style_options());
#else
- EXPECT_TRUE(app2->get_allow_windows_style_options());
+ CHECK(app2->get_allow_windows_style_options());
#endif
- EXPECT_TRUE(app2->get_fallthrough());
- EXPECT_TRUE(app2->get_validate_positionals());
- EXPECT_TRUE(app2->get_configurable());
- EXPECT_EQ(app2->get_footer(), "footy");
- EXPECT_EQ(app2->get_group(), "Stuff");
- EXPECT_EQ(app2->get_require_subcommand_min(), 0u);
- EXPECT_EQ(app2->get_require_subcommand_max(), 3u);
+ CHECK(app2->get_fallthrough());
+ CHECK(app2->get_validate_positionals());
+ CHECK(app2->get_configurable());
+ CHECK("footy" == app2->get_footer());
+ CHECK("Stuff" == app2->get_group());
+ CHECK(0u == app2->get_require_subcommand_min());
+ CHECK(3u == app2->get_require_subcommand_max());
}
-TEST_F(TApp, SubcommandMinMax) {
+TEST_CASE_METHOD(TApp, "SubcommandMinMax", "[creation]") {
- EXPECT_EQ(app.get_require_subcommand_min(), 0u);
- EXPECT_EQ(app.get_require_subcommand_max(), 0u);
+ CHECK(0u == app.get_require_subcommand_min());
+ CHECK(0u == app.get_require_subcommand_max());
app.require_subcommand();
- EXPECT_EQ(app.get_require_subcommand_min(), 1u);
- EXPECT_EQ(app.get_require_subcommand_max(), 0u);
+ CHECK(1u == app.get_require_subcommand_min());
+ CHECK(0u == app.get_require_subcommand_max());
app.require_subcommand(2);
- EXPECT_EQ(app.get_require_subcommand_min(), 2u);
- EXPECT_EQ(app.get_require_subcommand_max(), 2u);
+ CHECK(2u == app.get_require_subcommand_min());
+ CHECK(2u == app.get_require_subcommand_max());
app.require_subcommand(0);
- EXPECT_EQ(app.get_require_subcommand_min(), 0u);
- EXPECT_EQ(app.get_require_subcommand_max(), 0u);
+ CHECK(0u == app.get_require_subcommand_min());
+ CHECK(0u == app.get_require_subcommand_max());
app.require_subcommand(-2);
- EXPECT_EQ(app.get_require_subcommand_min(), 0u);
- EXPECT_EQ(app.get_require_subcommand_max(), 2u);
+ CHECK(0u == app.get_require_subcommand_min());
+ CHECK(2u == app.get_require_subcommand_max());
app.require_subcommand(3, 7);
- EXPECT_EQ(app.get_require_subcommand_min(), 3u);
- EXPECT_EQ(app.get_require_subcommand_max(), 7u);
+ CHECK(3u == app.get_require_subcommand_min());
+ CHECK(7u == app.get_require_subcommand_max());
}
-TEST_F(TApp, GetOptionList) {
+TEST_CASE_METHOD(TApp, "GetOptionList", "[creation]") {
int two{0};
auto flag = app.add_flag("--one");
auto opt = app.add_option("--two", two);
@@ -536,36 +539,36 @@ TEST_F(TApp, GetOptionList) {
const CLI::App &const_app = app; // const alias to force use of const-methods
std::vector<const CLI::Option *> opt_list = const_app.get_options();
- ASSERT_EQ(opt_list.size(), static_cast<std::size_t>(3));
- EXPECT_EQ(opt_list.at(1), flag);
- EXPECT_EQ(opt_list.at(2), opt);
+ REQUIRE(static_cast<std::size_t>(3) == opt_list.size());
+ CHECK(flag == opt_list.at(1));
+ CHECK(opt == opt_list.at(2));
std::vector<CLI::Option *> nonconst_opt_list = app.get_options();
for(std::size_t i = 0; i < opt_list.size(); ++i) {
- EXPECT_EQ(nonconst_opt_list.at(i), opt_list.at(i));
+ CHECK(opt_list.at(i) == nonconst_opt_list.at(i));
}
}
-TEST(ValidatorTests, TestValidatorCreation) {
+TEST_CASE("ValidatorTests: TestValidatorCreation", "[creation]") {
std::function<std::string(std::string &)> op1 = [](std::string &val) {
return (val.size() >= 5) ? std::string{} : val;
};
CLI::Validator V(op1, "", "size");
- EXPECT_EQ(V.get_name(), "size");
+ CHECK("size" == V.get_name());
V.name("harry");
- EXPECT_EQ(V.get_name(), "harry");
- EXPECT_TRUE(V.get_active());
+ CHECK("harry" == V.get_name());
+ CHECK(V.get_active());
- EXPECT_EQ(V("test"), "test");
- EXPECT_EQ(V("test5"), std::string{});
+ CHECK("test" == V("test"));
+ CHECK(std::string{} == V("test5"));
- EXPECT_EQ(V.get_description(), std::string{});
+ CHECK(std::string{} == V.get_description());
V.description("this is a description");
- EXPECT_EQ(V.get_description(), "this is a description");
+ CHECK("this is a description" == V.get_description());
}
-TEST(ValidatorTests, TestValidatorOps) {
+TEST_CASE("ValidatorTests: TestValidatorOps", "[creation]") {
std::function<std::string(std::string &)> op1 = [](std::string &val) {
return (val.size() >= 5) ? std::string{} : val;
};
@@ -590,72 +593,72 @@ TEST(ValidatorTests, TestValidatorOps) {
std::string eight(8, 'a');
std::string nine(9, 'a');
std::string ten(10, 'a');
- EXPECT_TRUE(V1(five).empty());
- EXPECT_FALSE(V1(four).empty());
+ CHECK(V1(five).empty());
+ CHECK(!V1(four).empty());
- EXPECT_TRUE(V2(nine).empty());
- EXPECT_FALSE(V2(eight).empty());
+ CHECK(V2(nine).empty());
+ CHECK(!V2(eight).empty());
- EXPECT_TRUE(V3(two).empty());
- EXPECT_FALSE(V3(four).empty());
+ CHECK(V3(two).empty());
+ CHECK(!V3(four).empty());
- EXPECT_TRUE(V4(eight).empty());
- EXPECT_FALSE(V4(ten).empty());
+ CHECK(V4(eight).empty());
+ CHECK(!V4(ten).empty());
auto V1a2 = V1 & V2;
- EXPECT_EQ(V1a2.get_description(), "(SIZE >= 5) AND (SIZE >= 9)");
- EXPECT_FALSE(V1a2(five).empty());
- EXPECT_TRUE(V1a2(nine).empty());
+ CHECK("(SIZE >= 5) AND (SIZE >= 9)" == V1a2.get_description());
+ CHECK(!V1a2(five).empty());
+ CHECK(V1a2(nine).empty());
auto V1a4 = V1 & V4;
- EXPECT_EQ(V1a4.get_description(), "(SIZE >= 5) AND (SIZE <= 9)");
- EXPECT_TRUE(V1a4(five).empty());
- EXPECT_TRUE(V1a4(eight).empty());
- EXPECT_FALSE(V1a4(ten).empty());
- EXPECT_FALSE(V1a4(four).empty());
+ CHECK("(SIZE >= 5) AND (SIZE <= 9)" == V1a4.get_description());
+ CHECK(V1a4(five).empty());
+ CHECK(V1a4(eight).empty());
+ CHECK(!V1a4(ten).empty());
+ CHECK(!V1a4(four).empty());
auto V1o3 = V1 | V3;
- EXPECT_EQ(V1o3.get_description(), "(SIZE >= 5) OR (SIZE < 3)");
- EXPECT_TRUE(V1o3(two).empty());
- EXPECT_TRUE(V1o3(eight).empty());
- EXPECT_TRUE(V1o3(ten).empty());
- EXPECT_TRUE(V1o3(two).empty());
- EXPECT_FALSE(V1o3(four).empty());
+ CHECK("(SIZE >= 5) OR (SIZE < 3)" == V1o3.get_description());
+ CHECK(V1o3(two).empty());
+ CHECK(V1o3(eight).empty());
+ CHECK(V1o3(ten).empty());
+ CHECK(V1o3(two).empty());
+ CHECK(!V1o3(four).empty());
auto m1 = V1o3 & V4;
- EXPECT_EQ(m1.get_description(), "((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)");
- EXPECT_TRUE(m1(two).empty());
- EXPECT_TRUE(m1(eight).empty());
- EXPECT_FALSE(m1(ten).empty());
- EXPECT_TRUE(m1(two).empty());
- EXPECT_TRUE(m1(five).empty());
- EXPECT_FALSE(m1(four).empty());
+ CHECK("((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)" == m1.get_description());
+ CHECK(m1(two).empty());
+ CHECK(m1(eight).empty());
+ CHECK(!m1(ten).empty());
+ CHECK(m1(two).empty());
+ CHECK(m1(five).empty());
+ CHECK(!m1(four).empty());
auto m2 = m1 & V2;
- EXPECT_EQ(m2.get_description(), "(((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)) AND (SIZE >= 9)");
- EXPECT_FALSE(m2(two).empty());
- EXPECT_FALSE(m2(eight).empty());
- EXPECT_FALSE(m2(ten).empty());
- EXPECT_FALSE(m2(two).empty());
- EXPECT_TRUE(m2(nine).empty());
- EXPECT_FALSE(m2(four).empty());
+ CHECK("(((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)) AND (SIZE >= 9)" == m2.get_description());
+ CHECK(!m2(two).empty());
+ CHECK(!m2(eight).empty());
+ CHECK(!m2(ten).empty());
+ CHECK(!m2(two).empty());
+ CHECK(m2(nine).empty());
+ CHECK(!m2(four).empty());
auto m3 = m2 | V3;
- EXPECT_EQ(m3.get_description(), "((((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)) AND (SIZE >= 9)) OR (SIZE < 3)");
- EXPECT_TRUE(m3(two).empty());
- EXPECT_FALSE(m3(eight).empty());
- EXPECT_TRUE(m3(nine).empty());
- EXPECT_FALSE(m3(four).empty());
+ CHECK("((((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)) AND (SIZE >= 9)) OR (SIZE < 3)" == m3.get_description());
+ CHECK(m3(two).empty());
+ CHECK(!m3(eight).empty());
+ CHECK(m3(nine).empty());
+ CHECK(!m3(four).empty());
auto m4 = V3 | m2;
- EXPECT_EQ(m4.get_description(), "(SIZE < 3) OR ((((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)) AND (SIZE >= 9))");
- EXPECT_TRUE(m4(two).empty());
- EXPECT_FALSE(m4(eight).empty());
- EXPECT_TRUE(m4(nine).empty());
- EXPECT_FALSE(m4(four).empty());
+ CHECK("(SIZE < 3) OR ((((SIZE >= 5) OR (SIZE < 3)) AND (SIZE <= 9)) AND (SIZE >= 9))" == m4.get_description());
+ CHECK(m4(two).empty());
+ CHECK(!m4(eight).empty());
+ CHECK(m4(nine).empty());
+ CHECK(!m4(four).empty());
}
-TEST(ValidatorTests, TestValidatorNegation) {
+TEST_CASE("ValidatorTests: TestValidatorNegation", "[creation]") {
std::function<std::string(std::string &)> op1 = [](std::string &val) {
return (val.size() >= 5) ? std::string{} : val;
@@ -666,21 +669,21 @@ TEST(ValidatorTests, TestValidatorNegation) {
std::string four(4, 'a');
std::string five(5, 'a');
- EXPECT_TRUE(V1(five).empty());
- EXPECT_FALSE(V1(four).empty());
+ CHECK(V1(five).empty());
+ CHECK(!V1(four).empty());
auto V2 = !V1;
- EXPECT_FALSE(V2(five).empty());
- EXPECT_TRUE(V2(four).empty());
- EXPECT_EQ(V2.get_description(), "NOT SIZE >= 5");
+ CHECK(!V2(five).empty());
+ CHECK(V2(four).empty());
+ CHECK("NOT SIZE >= 5" == V2.get_description());
V2.active(false);
- EXPECT_TRUE(V2(five).empty());
- EXPECT_TRUE(V2(four).empty());
- EXPECT_TRUE(V2.get_description().empty());
+ CHECK(V2(five).empty());
+ CHECK(V2(four).empty());
+ CHECK(V2.get_description().empty());
}
-TEST(ValidatorTests, ValidatorDefaults) {
+TEST_CASE("ValidatorTests: ValidatorDefaults", "[creation]") {
CLI::Validator V1{};
@@ -688,23 +691,23 @@ TEST(ValidatorTests, ValidatorDefaults) {
std::string five(5, 'a');
// make sure this doesn't generate a seg fault or something
- EXPECT_TRUE(V1(five).empty());
- EXPECT_TRUE(V1(four).empty());
+ CHECK(V1(five).empty());
+ CHECK(V1(four).empty());
- EXPECT_TRUE(V1.get_name().empty());
- EXPECT_TRUE(V1.get_description().empty());
- EXPECT_TRUE(V1.get_active());
- EXPECT_TRUE(V1.get_modifying());
+ CHECK(V1.get_name().empty());
+ CHECK(V1.get_description().empty());
+ CHECK(V1.get_active());
+ CHECK(V1.get_modifying());
CLI::Validator V2{"check"};
// make sure this doesn't generate a seg fault or something
- EXPECT_TRUE(V2(five).empty());
- EXPECT_TRUE(V2(four).empty());
+ CHECK(V2(five).empty());
+ CHECK(V2(four).empty());
- EXPECT_TRUE(V2.get_name().empty());
- EXPECT_EQ(V2.get_description(), "check");
- EXPECT_TRUE(V2.get_active());
- EXPECT_TRUE(V2.get_modifying());
+ CHECK(V2.get_name().empty());
+ CHECK("check" == V2.get_description());
+ CHECK(V2.get_active());
+ CHECK(V2.get_modifying());
// This class only support streaming in, not out
}
@@ -731,7 +734,7 @@ std::istream &operator>>(std::istream &in, Unstreamable &value) {
static_assert(CLI::detail::is_istreamable<Unstreamable>::value,
"Unstreamable type is still unstreamable and it should be");
-TEST_F(TApp, MakeUnstreamableOptions) {
+TEST_CASE_METHOD(TApp, "MakeUnstreamableOptions", "[creation]") {
Unstreamable value;
app.add_option("--value", value);
@@ -746,10 +749,10 @@ TEST_F(TApp, MakeUnstreamableOptions) {
args = {"--value", "45"};
run();
- EXPECT_EQ(value.get_x(), 45);
+ CHECK(45 == value.get_x());
args = {"--values", "45", "27", "34"};
run();
- EXPECT_EQ(values.size(), 3u);
- EXPECT_EQ(values[2].get_x(), 34);
+ CHECK(3u == values.size());
+ CHECK(34 == values[2].get_x());
}
diff --git a/packages/CLI11/tests/DeprecatedTest.cpp b/packages/CLI11/tests/DeprecatedTest.cpp
index a8f41971270021c57f50ff64dcb5f97387175791..cf9987c6d97b6a8251630f60deff8e5466138e28 100644
--- a/packages/CLI11/tests/DeprecatedTest.cpp
+++ b/packages/CLI11/tests/DeprecatedTest.cpp
@@ -6,157 +6,16 @@
#include "app_helper.hpp"
-#include "gmock/gmock.h"
+using Catch::Matchers::Contains;
-using ::testing::HasSubstr;
-using ::testing::Not;
-
-TEST(Deprecated, Empty) {
+TEST_CASE("Deprecated: Empty", "[deprecated]") {
// No deprecated features at this time.
- EXPECT_TRUE(true);
+ CHECK(true);
}
// Classic sets
-TEST_F(TApp, SetWithDefaults) {
- int someint = 2;
- app.add_set("-a", someint, {1, 2, 3, 4}, "", true);
-
- args = {"-a1", "-a2"};
-
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
-}
-
-TEST_F(TApp, SetWithDefaultsConversion) {
- int someint = 2;
- app.add_set("-a", someint, {1, 2, 3, 4}, "", true);
-
- args = {"-a", "hi"};
-
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, InSet) {
-
- std::string choice;
- app.add_set("-q,--quick", choice, {"one", "two", "three"});
-
- args = {"--quick", "two"};
-
- run();
- EXPECT_EQ("two", choice);
-
- args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, InSetWithDefault) {
-
- std::string choice = "one";
- app.add_set("-q,--quick", choice, {"one", "two", "three"}, "", true);
-
- run();
- EXPECT_EQ("one", choice);
-
- args = {"--quick", "two"};
-
- run();
- EXPECT_EQ("two", choice);
-
- args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, InIntSet) {
-
- int choice;
- app.add_set("-q,--quick", choice, {1, 2, 3});
-
- args = {"--quick", "2"};
-
- run();
- EXPECT_EQ(2, choice);
-
- args = {"--quick", "4"};
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, InIntSetWindows) {
-
- int choice;
- app.add_set("-q,--quick", choice, {1, 2, 3});
- app.allow_windows_style_options();
- args = {"/q", "2"};
-
- run();
- EXPECT_EQ(2, choice);
-
- args = {"/q", "4"};
- EXPECT_THROW(run(), CLI::ValidationError);
-
- args = {"/q4"};
- EXPECT_THROW(run(), CLI::ExtrasError);
-}
-
-TEST_F(TApp, FailSet) {
-
- int choice;
- app.add_set("-q,--quick", choice, {1, 2, 3});
-
- args = {"--quick", "3", "--quick=2"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
-
- args = {"--quick=hello"};
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, FailMutableSet) {
-
- int choice;
- std::set<int> vals{1, 2, 3};
- app.add_mutable_set("-q,--quick", choice, vals);
- app.add_mutable_set("-s,--slow", choice, vals, "", true);
-
- args = {"--quick=hello"};
- EXPECT_THROW(run(), CLI::ValidationError);
-
- args = {"--slow=hello"};
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-// #113
-TEST_F(TApp, AddRemoveSetItems) {
- std::set<std::string> items{"TYPE1", "TYPE2", "TYPE3", "TYPE4", "TYPE5"};
-
- std::string type1, type2;
- app.add_mutable_set("--type1", type1, items);
- app.add_mutable_set("--type2", type2, items, "", true);
-
- args = {"--type1", "TYPE1", "--type2", "TYPE2"};
-
- run();
- EXPECT_EQ(type1, "TYPE1");
- EXPECT_EQ(type2, "TYPE2");
-
- items.insert("TYPE6");
- items.insert("TYPE7");
-
- items.erase("TYPE1");
- items.erase("TYPE2");
-
- args = {"--type1", "TYPE6", "--type2", "TYPE7"};
- run();
- EXPECT_EQ(type1, "TYPE6");
- EXPECT_EQ(type2, "TYPE7");
-
- args = {"--type1", "TYPE1"};
- EXPECT_THROW(run(), CLI::ValidationError);
-
- args = {"--type2", "TYPE2"};
- EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST(THelp, Defaults) {
+TEST_CASE("THelp: Defaults", "[deprecated]") {
CLI::App app{"My prog"};
int one{1}, two{2};
@@ -165,24 +24,24 @@ TEST(THelp, Defaults) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("--one"));
- EXPECT_THAT(help, HasSubstr("--set"));
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("=2"));
- EXPECT_THAT(help, HasSubstr("2,3,4"));
+ CHECK_THAT(help, Contains("--one"));
+ CHECK_THAT(help, Contains("--set"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("=2"));
+ CHECK_THAT(help, Contains("2,3,4"));
}
-TEST(THelp, VectorOpts) {
+TEST_CASE("THelp: VectorOpts", "[deprecated]") {
CLI::App app{"My prog"};
std::vector<int> x = {1, 2};
app.add_option("-q,--quick", x, "", true);
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("INT=[1,2] ..."));
+ CHECK_THAT(help, Contains("INT=[1,2] ..."));
}
-TEST(THelp, SetLower) {
+TEST_CASE("THelp: SetLower", "[deprecated]") {
CLI::App app{"My prog"};
std::string def{"One"};
@@ -190,14 +49,14 @@ TEST(THelp, SetLower) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("--set"));
- EXPECT_THAT(help, HasSubstr("=One"));
- EXPECT_THAT(help, HasSubstr("oNe"));
- EXPECT_THAT(help, HasSubstr("twO"));
- EXPECT_THAT(help, HasSubstr("THREE"));
+ CHECK_THAT(help, Contains("--set"));
+ CHECK_THAT(help, Contains("=One"));
+ CHECK_THAT(help, Contains("oNe"));
+ CHECK_THAT(help, Contains("twO"));
+ CHECK_THAT(help, Contains("THREE"));
}
-TEST(THelp, ChangingSetDefaulted) {
+TEST_CASE("THelp: ChangingSetDefaulted", "[deprecated]") {
CLI::App app;
std::set<int> vals{1, 2, 3};
@@ -206,19 +65,19 @@ TEST(THelp, ChangingSetDefaulted) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, Not(HasSubstr("4")));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, !Contains("4"));
vals.insert(4);
vals.erase(1);
help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("1")));
- EXPECT_THAT(help, HasSubstr("4"));
+ CHECK_THAT(help, !Contains("1"));
+ CHECK_THAT(help, Contains("4"));
}
-TEST(THelp, ChangingCaselessSetDefaulted) {
+TEST_CASE("THelp: ChangingCaselessSetDefaulted", "[deprecated]") {
CLI::App app;
std::set<std::string> vals{"1", "2", "3"};
@@ -227,19 +86,19 @@ TEST(THelp, ChangingCaselessSetDefaulted) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, Not(HasSubstr("4")));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, !Contains("4"));
vals.insert("4");
vals.erase("1");
help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("1")));
- EXPECT_THAT(help, HasSubstr("4"));
+ CHECK_THAT(help, !Contains("1"));
+ CHECK_THAT(help, Contains("4"));
}
-TEST_F(TApp, DefaultOpts) {
+TEST_CASE_METHOD(TApp, "DefaultOpts", "[deprecated]") {
int i = 3;
std::string s = "HI";
@@ -251,116 +110,116 @@ TEST_F(TApp, DefaultOpts) {
run();
- EXPECT_EQ(1u, app.count("i"));
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(2, i);
- EXPECT_EQ("9", s);
+ CHECK(app.count("i") == 1u);
+ CHECK(app.count("-s") == 1u);
+ CHECK(i == 2);
+ CHECK(s == "9");
}
-TEST_F(TApp, VectorDefaultedFixedString) {
+TEST_CASE_METHOD(TApp, "VectorDefaultedFixedString", "[deprecated]") {
std::vector<std::string> strvec{"one"};
std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
CLI::Option *opt = app.add_option("-s,--string", strvec, "", true)->expected(3);
- EXPECT_EQ(3, opt->get_expected());
+ CHECK(opt->get_expected() == 3);
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
- EXPECT_EQ(answer, strvec);
+ CHECK(app.count("--string") == 3u);
+ CHECK(strvec == answer);
}
-TEST_F(TApp, DefaultedResult) {
+TEST_CASE_METHOD(TApp, "DefaultedResult", "[deprecated]") {
std::string sval = "NA";
int ival;
auto opts = app.add_option("--string", sval, "", true);
auto optv = app.add_option("--val", ival);
args = {};
run();
- EXPECT_EQ(sval, "NA");
+ CHECK("NA" == sval);
std::string nString;
opts->results(nString);
- EXPECT_EQ(nString, "NA");
+ CHECK("NA" == nString);
int newIval;
- // EXPECT_THROW(optv->results(newIval), CLI::ConversionError);
+ // CHECK_THROWS_AS (optv->results(newIval), CLI::ConversionError);
optv->default_str("442");
optv->results(newIval);
- EXPECT_EQ(newIval, 442);
+ CHECK(442 == newIval);
}
-TEST_F(TApp, OptionWithDefaults) {
+TEST_CASE_METHOD(TApp, "OptionWithDefaults", "[deprecated]") {
int someint = 2;
app.add_option("-a", someint, "", true);
args = {"-a1", "-a2"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
// #209
-TEST_F(TApp, CustomUserSepParse) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse", "[deprecated]") {
std::vector<int> vals = {1, 2, 3};
args = {"--idx", "1,2,3"};
auto opt = app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
std::vector<int> vals2;
// check that the results vector gets the results in the same way
opt->results(vals2);
- EXPECT_EQ(vals2, vals);
+ CHECK(vals == vals2);
app.remove_option(opt);
app.add_option("--idx", vals, "", true)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
}
// #209
-TEST_F(TApp, CustomUserSepParse2) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse2", "[deprecated]") {
std::vector<int> vals = {1, 2, 3};
args = {"--idx", "1,2,"};
auto opt = app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
app.remove_option(opt);
app.add_option("--idx", vals, "", true)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
}
//
// #209
-TEST_F(TApp, CustomUserSepParse4) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse4", "[deprecated]") {
std::vector<int> vals;
args = {"--idx", "1, 2"};
auto opt = app.add_option("--idx", vals, "", true)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
app.remove_option(opt);
app.add_option("--idx", vals)->delimiter(',');
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == vals);
}
// #218
-TEST_F(TApp, CustomUserSepParse5) {
+TEST_CASE_METHOD(TApp, "CustomUserSepParse5", "[deprecated]") {
std::vector<std::string> bar;
args = {"this", "is", "a", "test"};
auto opt = app.add_option("bar", bar, "bar");
run();
- EXPECT_EQ(bar, std::vector<std::string>({"this", "is", "a", "test"}));
+ CHECK(std::vector<std::string>({"this", "is", "a", "test"}) == bar);
app.remove_option(opt);
args = {"this", "is", "a", "test"};
app.add_option("bar", bar, "bar", true);
run();
- EXPECT_EQ(bar, std::vector<std::string>({"this", "is", "a", "test"}));
+ CHECK(std::vector<std::string>({"this", "is", "a", "test"}) == bar);
}
diff --git a/packages/CLI11/tests/FormatterTest.cpp b/packages/CLI11/tests/FormatterTest.cpp
index 513f956a03bc1d20e01b6fb6a05821903a28e6f0..22da56f0e543af444e9caadd0c60a2932fe35018 100644
--- a/packages/CLI11/tests/FormatterTest.cpp
+++ b/packages/CLI11/tests/FormatterTest.cpp
@@ -10,12 +10,10 @@
#include "CLI/CLI.hpp"
#endif
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
+#include "catch.hpp"
#include <fstream>
-using ::testing::HasSubstr;
-using ::testing::Not;
+using Catch::Matchers::Contains;
class SimpleFormatter : public CLI::FormatterBase {
public:
@@ -26,17 +24,17 @@ class SimpleFormatter : public CLI::FormatterBase {
}
};
-TEST(Formatter, Nothing) {
+TEST_CASE("Formatter: Nothing", "[formatter]") {
CLI::App app{"My prog"};
app.formatter(std::make_shared<SimpleFormatter>());
std::string help = app.help();
- EXPECT_EQ(help, "This is really simple");
+ CHECK("This is really simple" == help);
}
-TEST(Formatter, NothingLambda) {
+TEST_CASE("Formatter: NothingLambda", "[formatter]") {
CLI::App app{"My prog"};
app.formatter_fn(
@@ -44,10 +42,10 @@ TEST(Formatter, NothingLambda) {
std::string help = app.help();
- EXPECT_EQ(help, "This is really simple");
+ CHECK("This is really simple" == help);
}
-TEST(Formatter, OptCustomize) {
+TEST_CASE("Formatter: OptCustomize", "[formatter]") {
CLI::App app{"My prog"};
auto optfmt = std::make_shared<CLI::Formatter>();
@@ -60,16 +58,15 @@ TEST(Formatter, OptCustomize) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("(MUST HAVE)"));
- EXPECT_EQ(help,
- "My prog\n"
- "Usage: [OPTIONS]\n\n"
- "Options:\n"
- " -h,--help Print this help message and exit\n"
- " --opt INT (MUST HAVE) Something\n\n");
+ CHECK_THAT(help, Contains("(MUST HAVE)"));
+ CHECK(help == "My prog\n"
+ "Usage: [OPTIONS]\n\n"
+ "Options:\n"
+ " -h,--help Print this help message and exit\n"
+ " --opt INT (MUST HAVE) Something\n\n");
}
-TEST(Formatter, OptCustomizeSimple) {
+TEST_CASE("Formatter: OptCustomizeSimple", "[formatter]") {
CLI::App app{"My prog"};
app.get_formatter()->column_width(25);
@@ -80,16 +77,15 @@ TEST(Formatter, OptCustomizeSimple) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("(MUST HAVE)"));
- EXPECT_EQ(help,
- "My prog\n"
- "Usage: [OPTIONS]\n\n"
- "Options:\n"
- " -h,--help Print this help message and exit\n"
- " --opt INT (MUST HAVE) Something\n\n");
+ CHECK_THAT(help, Contains("(MUST HAVE)"));
+ CHECK(help == "My prog\n"
+ "Usage: [OPTIONS]\n\n"
+ "Options:\n"
+ " -h,--help Print this help message and exit\n"
+ " --opt INT (MUST HAVE) Something\n\n");
}
-TEST(Formatter, OptCustomizeOptionText) {
+TEST_CASE("Formatter: OptCustomizeOptionText", "[formatter]") {
CLI::App app{"My prog"};
app.get_formatter()->column_width(25);
@@ -99,16 +95,15 @@ TEST(Formatter, OptCustomizeOptionText) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("(ARG)"));
- EXPECT_EQ(help,
- "My prog\n"
- "Usage: [OPTIONS]\n\n"
- "Options:\n"
- " -h,--help Print this help message and exit\n"
- " --opt (ARG) Something\n\n");
+ CHECK_THAT(help, Contains("(ARG)"));
+ CHECK(help == "My prog\n"
+ "Usage: [OPTIONS]\n\n"
+ "Options:\n"
+ " -h,--help Print this help message and exit\n"
+ " --opt (ARG) Something\n\n");
}
-TEST(Formatter, FalseFlagExample) {
+TEST_CASE("Formatter: FalseFlagExample", "[formatter]") {
CLI::App app{"My prog"};
app.get_formatter()->column_width(25);
@@ -122,12 +117,12 @@ TEST(Formatter, FalseFlagExample) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("--no_opt{false}"));
- EXPECT_THAT(help, HasSubstr("--no_opt2{false}"));
- EXPECT_THAT(help, HasSubstr("-O{false}"));
+ CHECK_THAT(help, Contains("--no_opt{false}"));
+ CHECK_THAT(help, Contains("--no_opt2{false}"));
+ CHECK_THAT(help, Contains("-O{false}"));
}
-TEST(Formatter, AppCustomize) {
+TEST_CASE("Formatter: AppCustomize", "[formatter]") {
CLI::App app{"My prog"};
app.add_subcommand("subcom1", "This");
@@ -139,17 +134,16 @@ TEST(Formatter, AppCustomize) {
app.add_subcommand("subcom2", "This");
std::string help = app.help();
- EXPECT_EQ(help,
- "My prog\n"
- "Run: [OPTIONS] [SUBCOMMAND]\n\n"
- "Options:\n"
- " -h,--help Print this help message and exit\n\n"
- "Subcommands:\n"
- " subcom1 This\n"
- " subcom2 This\n\n");
+ CHECK(help == "My prog\n"
+ "Run: [OPTIONS] [SUBCOMMAND]\n\n"
+ "Options:\n"
+ " -h,--help Print this help message and exit\n\n"
+ "Subcommands:\n"
+ " subcom1 This\n"
+ " subcom2 This\n\n");
}
-TEST(Formatter, AppCustomizeSimple) {
+TEST_CASE("Formatter: AppCustomizeSimple", "[formatter]") {
CLI::App app{"My prog"};
app.add_subcommand("subcom1", "This");
@@ -159,48 +153,47 @@ TEST(Formatter, AppCustomizeSimple) {
app.add_subcommand("subcom2", "This");
std::string help = app.help();
- EXPECT_EQ(help,
- "My prog\n"
- "Run: [OPTIONS] [SUBCOMMAND]\n\n"
- "Options:\n"
- " -h,--help Print this help message and exit\n\n"
- "Subcommands:\n"
- " subcom1 This\n"
- " subcom2 This\n\n");
+ CHECK(help == "My prog\n"
+ "Run: [OPTIONS] [SUBCOMMAND]\n\n"
+ "Options:\n"
+ " -h,--help Print this help message and exit\n\n"
+ "Subcommands:\n"
+ " subcom1 This\n"
+ " subcom2 This\n\n");
}
-TEST(Formatter, AllSub) {
+TEST_CASE("Formatter: AllSub", "[formatter]") {
CLI::App app{"My prog"};
CLI::App *sub = app.add_subcommand("subcom", "This");
sub->add_flag("--insub", "MyFlag");
std::string help = app.help("", CLI::AppFormatMode::All);
- EXPECT_THAT(help, HasSubstr("--insub"));
- EXPECT_THAT(help, HasSubstr("subcom"));
+ CHECK_THAT(help, Contains("--insub"));
+ CHECK_THAT(help, Contains("subcom"));
}
-TEST(Formatter, AllSubRequired) {
+TEST_CASE("Formatter: AllSubRequired", "[formatter]") {
CLI::App app{"My prog"};
CLI::App *sub = app.add_subcommand("subcom", "This");
sub->add_flag("--insub", "MyFlag");
sub->required();
std::string help = app.help("", CLI::AppFormatMode::All);
- EXPECT_THAT(help, HasSubstr("--insub"));
- EXPECT_THAT(help, HasSubstr("subcom"));
- EXPECT_THAT(help, HasSubstr("REQUIRED"));
+ CHECK_THAT(help, Contains("--insub"));
+ CHECK_THAT(help, Contains("subcom"));
+ CHECK_THAT(help, Contains("REQUIRED"));
}
-TEST(Formatter, NamelessSub) {
+TEST_CASE("Formatter: NamelessSub", "[formatter]") {
CLI::App app{"My prog"};
CLI::App *sub = app.add_subcommand("", "This subcommand");
sub->add_flag("--insub", "MyFlag");
std::string help = app.help("", CLI::AppFormatMode::Normal);
- EXPECT_THAT(help, HasSubstr("--insub"));
- EXPECT_THAT(help, HasSubstr("This subcommand"));
+ CHECK_THAT(help, Contains("--insub"));
+ CHECK_THAT(help, Contains("This subcommand"));
}
-TEST(Formatter, NamelessSubInGroup) {
+TEST_CASE("Formatter: NamelessSubInGroup", "[formatter]") {
CLI::App app{"My prog"};
CLI::App *sub = app.add_subcommand("", "This subcommand");
CLI::App *sub2 = app.add_subcommand("sub2", "subcommand2");
@@ -210,9 +203,9 @@ TEST(Formatter, NamelessSubInGroup) {
sub->group("group1");
sub2->group("group1");
std::string help = app.help("", CLI::AppFormatMode::Normal);
- EXPECT_THAT(help, HasSubstr("--insub"));
- EXPECT_THAT(help, HasSubstr("This subcommand"));
- EXPECT_THAT(help, HasSubstr("group1"));
- EXPECT_THAT(help, HasSubstr("sub2"));
- EXPECT_TRUE(help.find("pos") == std::string::npos);
+ CHECK_THAT(help, Contains("--insub"));
+ CHECK_THAT(help, Contains("This subcommand"));
+ CHECK_THAT(help, Contains("group1"));
+ CHECK_THAT(help, Contains("sub2"));
+ CHECK(help.find("pos") == std::string::npos);
}
diff --git a/packages/CLI11/tests/HelpTest.cpp b/packages/CLI11/tests/HelpTest.cpp
index a6169dfebbdcaa907f2163b57610941e6338a810..48089f6fc76ea10a7446447ebf8114fdd9797553 100644
--- a/packages/CLI11/tests/HelpTest.cpp
+++ b/packages/CLI11/tests/HelpTest.cpp
@@ -10,65 +10,63 @@
#include "CLI/CLI.hpp"
#endif
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
+#include "catch.hpp"
#include <fstream>
-using ::testing::HasSubstr;
-using ::testing::Not;
+using Catch::Matchers::Contains;
-TEST(THelp, Basic) {
+TEST_CASE("THelp: Basic", "[help]") {
CLI::App app{"My prog"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage:"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
}
-TEST(THelp, Footer) {
+TEST_CASE("THelp: Footer", "[help]") {
CLI::App app{"My prog"};
app.footer("Report bugs to bugs@example.com");
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage:"));
- EXPECT_THAT(help, HasSubstr("Report bugs to bugs@example.com"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
+ CHECK_THAT(help, Contains("Report bugs to bugs@example.com"));
}
-TEST(THelp, FooterCallback) {
+TEST_CASE("THelp: FooterCallback", "[help]") {
CLI::App app{"My prog"};
app.footer([]() { return "Report bugs to bugs@example.com"; });
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage:"));
- EXPECT_THAT(help, HasSubstr("Report bugs to bugs@example.com"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
+ CHECK_THAT(help, Contains("Report bugs to bugs@example.com"));
}
-TEST(THelp, FooterCallbackBoth) {
+TEST_CASE("THelp: FooterCallbackBoth", "[help]") {
CLI::App app{"My prog"};
app.footer([]() { return "Report bugs to bugs@example.com"; });
app.footer(" foot!!!!");
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage:"));
- EXPECT_THAT(help, HasSubstr("Report bugs to bugs@example.com"));
- EXPECT_THAT(help, HasSubstr("foot!!!!"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
+ CHECK_THAT(help, Contains("Report bugs to bugs@example.com"));
+ CHECK_THAT(help, Contains("foot!!!!"));
}
-TEST(THelp, OptionalPositional) {
+TEST_CASE("THelp: OptionalPositional", "[help]") {
CLI::App app{"My prog", "program"};
std::string x;
@@ -76,16 +74,16 @@ TEST(THelp, OptionalPositional) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Positionals:"));
- EXPECT_THAT(help, HasSubstr("something TEXT"));
- EXPECT_THAT(help, HasSubstr("My option here"));
- EXPECT_THAT(help, HasSubstr("Usage: program [OPTIONS] [something]"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Positionals:"));
+ CHECK_THAT(help, Contains("something TEXT"));
+ CHECK_THAT(help, Contains("My option here"));
+ CHECK_THAT(help, Contains("Usage: program [OPTIONS] [something]"));
}
-TEST(THelp, Hidden) {
+TEST_CASE("THelp: Hidden", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -95,15 +93,15 @@ TEST(THelp, Hidden) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, Not(HasSubstr("[something]")));
- EXPECT_THAT(help, Not(HasSubstr("something ")));
- EXPECT_THAT(help, Not(HasSubstr("another")));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, !Contains("[something]"));
+ CHECK_THAT(help, !Contains("something "));
+ CHECK_THAT(help, !Contains("another"));
}
-TEST(THelp, deprecatedOptions) {
+TEST_CASE("THelp: deprecatedOptions", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -116,12 +114,12 @@ TEST(THelp, deprecatedOptions) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("DEPRECATED"));
- EXPECT_THAT(help, HasSubstr("something"));
- EXPECT_NO_THROW(app.parse("--something deprecated"));
+ CHECK_THAT(help, Contains("DEPRECATED"));
+ CHECK_THAT(help, Contains("something"));
+ CHECK_NOTHROW(app.parse("--something deprecated"));
}
-TEST(THelp, deprecatedOptions2) {
+TEST_CASE("THelp: deprecatedOptions2", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -134,12 +132,12 @@ TEST(THelp, deprecatedOptions2) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("DEPRECATED"));
- EXPECT_THAT(help, HasSubstr("something"));
- EXPECT_NO_THROW(app.parse("--something deprecated"));
+ CHECK_THAT(help, Contains("DEPRECATED"));
+ CHECK_THAT(help, Contains("something"));
+ CHECK_NOTHROW(app.parse("--something deprecated"));
}
-TEST(THelp, deprecatedOptions3) {
+TEST_CASE("THelp: deprecatedOptions3", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -152,12 +150,12 @@ TEST(THelp, deprecatedOptions3) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("DEPRECATED"));
- EXPECT_THAT(help, HasSubstr("'--something_else' instead"));
- EXPECT_NO_THROW(app.parse("--something deprecated"));
+ CHECK_THAT(help, Contains("DEPRECATED"));
+ CHECK_THAT(help, Contains("'--something_else' instead"));
+ CHECK_NOTHROW(app.parse("--something deprecated"));
}
-TEST(THelp, retiredOptions) {
+TEST_CASE("THelp: retiredOptions", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -170,13 +168,13 @@ TEST(THelp, retiredOptions) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("RETIRED"));
- EXPECT_THAT(help, HasSubstr("something"));
+ CHECK_THAT(help, Contains("RETIRED"));
+ CHECK_THAT(help, Contains("something"));
- EXPECT_NO_THROW(app.parse("--something old"));
+ CHECK_NOTHROW(app.parse("--something old"));
}
-TEST(THelp, retiredOptions2) {
+TEST_CASE("THelp: retiredOptions2", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -188,12 +186,12 @@ TEST(THelp, retiredOptions2) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("RETIRED"));
- EXPECT_THAT(help, HasSubstr("something"));
- EXPECT_NO_THROW(app.parse("--something old"));
+ CHECK_THAT(help, Contains("RETIRED"));
+ CHECK_THAT(help, Contains("something"));
+ CHECK_NOTHROW(app.parse("--something old"));
}
-TEST(THelp, retiredOptions3) {
+TEST_CASE("THelp: retiredOptions3", "[help]") {
CLI::App app{"My prog"};
std::string x;
@@ -206,13 +204,13 @@ TEST(THelp, retiredOptions3) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("RETIRED"));
- EXPECT_THAT(help, HasSubstr("something"));
+ CHECK_THAT(help, Contains("RETIRED"));
+ CHECK_THAT(help, Contains("something"));
- EXPECT_NO_THROW(app.parse("--something old"));
+ CHECK_NOTHROW(app.parse("--something old"));
}
-TEST(THelp, HiddenGroup) {
+TEST_CASE("THelp: HiddenGroup", "[help]") {
CLI::App app{"My prog"};
// empty option group name should be hidden
auto hgroup = app.add_option_group("");
@@ -223,22 +221,22 @@ TEST(THelp, HiddenGroup) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, Not(HasSubstr("[something]")));
- EXPECT_THAT(help, Not(HasSubstr("something ")));
- EXPECT_THAT(help, Not(HasSubstr("another")));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, !Contains("[something]"));
+ CHECK_THAT(help, !Contains("something "));
+ CHECK_THAT(help, !Contains("another"));
hgroup->group("ghidden");
help = app.help();
- EXPECT_THAT(help, HasSubstr("something "));
- EXPECT_THAT(help, HasSubstr("another"));
+ CHECK_THAT(help, Contains("something "));
+ CHECK_THAT(help, Contains("another"));
}
-TEST(THelp, OptionalPositionalAndOptions) {
+TEST_CASE("THelp: OptionalPositionalAndOptions", "[help]") {
CLI::App app{"My prog", "AnotherProgram"};
app.add_flag("-q,--quick");
@@ -247,13 +245,13 @@ TEST(THelp, OptionalPositionalAndOptions) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage: AnotherProgram [OPTIONS] [something]"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage: AnotherProgram [OPTIONS] [something]"));
}
-TEST(THelp, RequiredPositionalAndOptions) {
+TEST_CASE("THelp: RequiredPositionalAndOptions", "[help]") {
CLI::App app{"My prog"};
app.add_flag("-q,--quick");
@@ -262,14 +260,14 @@ TEST(THelp, RequiredPositionalAndOptions) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("-h,--help"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Positionals:"));
- EXPECT_THAT(help, HasSubstr("Usage: [OPTIONS] something"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("-h,--help"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Positionals:"));
+ CHECK_THAT(help, Contains("Usage: [OPTIONS] something"));
}
-TEST(THelp, MultiOpts) {
+TEST_CASE("THelp: MultiOpts", "[help]") {
CLI::App app{"My prog"};
std::vector<int> x, y;
app.add_option("-q,--quick", x, "Disc")->expected(2);
@@ -277,24 +275,24 @@ TEST(THelp, MultiOpts) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, Not(HasSubstr("Positionals:")));
- EXPECT_THAT(help, HasSubstr("Usage: [OPTIONS]"));
- EXPECT_THAT(help, HasSubstr("INT x 2"));
- EXPECT_THAT(help, HasSubstr("INT ..."));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, !Contains("Positionals:"));
+ CHECK_THAT(help, Contains("Usage: [OPTIONS]"));
+ CHECK_THAT(help, Contains("INT x 2"));
+ CHECK_THAT(help, Contains("INT ..."));
}
-TEST(THelp, VectorOpts) {
+TEST_CASE("THelp: VectorOpts", "[help]") {
CLI::App app{"My prog"};
std::vector<int> x = {1, 2};
app.add_option("-q,--quick", x)->capture_default_str();
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("INT=[1,2] ..."));
+ CHECK_THAT(help, Contains("INT=[1,2] ..."));
}
-TEST(THelp, MultiPosOpts) {
+TEST_CASE("THelp: MultiPosOpts", "[help]") {
CLI::App app{"My prog"};
app.name("program");
std::vector<int> x, y;
@@ -303,26 +301,26 @@ TEST(THelp, MultiPosOpts) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, HasSubstr("Positionals:"));
- EXPECT_THAT(help, HasSubstr("Usage: program [OPTIONS]"));
- EXPECT_THAT(help, HasSubstr("INT x 2"));
- EXPECT_THAT(help, HasSubstr("INT ..."));
- EXPECT_THAT(help, HasSubstr("[quick(2x)]"));
- EXPECT_THAT(help, HasSubstr("[vals...]"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, Contains("Positionals:"));
+ CHECK_THAT(help, Contains("Usage: program [OPTIONS]"));
+ CHECK_THAT(help, Contains("INT x 2"));
+ CHECK_THAT(help, Contains("INT ..."));
+ CHECK_THAT(help, Contains("[quick(2x)]"));
+ CHECK_THAT(help, Contains("[vals...]"));
}
-TEST(THelp, EnvName) {
+TEST_CASE("THelp: EnvName", "[help]") {
CLI::App app{"My prog"};
std::string input;
app.add_option("--something", input)->envname("SOME_ENV");
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("SOME_ENV"));
+ CHECK_THAT(help, Contains("SOME_ENV"));
}
-TEST(THelp, Needs) {
+TEST_CASE("THelp: Needs", "[help]") {
CLI::App app{"My prog"};
CLI::Option *op1 = app.add_flag("--op1");
@@ -330,10 +328,10 @@ TEST(THelp, Needs) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Needs: --op1"));
+ CHECK_THAT(help, Contains("Needs: --op1"));
}
-TEST(THelp, NeedsPositional) {
+TEST_CASE("THelp: NeedsPositional", "[help]") {
CLI::App app{"My prog"};
int x{0}, y{0};
@@ -343,11 +341,11 @@ TEST(THelp, NeedsPositional) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Positionals:"));
- EXPECT_THAT(help, HasSubstr("Needs: op1"));
+ CHECK_THAT(help, Contains("Positionals:"));
+ CHECK_THAT(help, Contains("Needs: op1"));
}
-TEST(THelp, Excludes) {
+TEST_CASE("THelp: Excludes", "[help]") {
CLI::App app{"My prog"};
CLI::Option *op1 = app.add_flag("--op1");
@@ -355,10 +353,10 @@ TEST(THelp, Excludes) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Excludes: --op1"));
+ CHECK_THAT(help, Contains("Excludes: --op1"));
}
-TEST(THelp, ExcludesPositional) {
+TEST_CASE("THelp: ExcludesPositional", "[help]") {
CLI::App app{"My prog"};
int x{0}, y{0};
@@ -368,11 +366,11 @@ TEST(THelp, ExcludesPositional) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Positionals:"));
- EXPECT_THAT(help, HasSubstr("Excludes: op1"));
+ CHECK_THAT(help, Contains("Positionals:"));
+ CHECK_THAT(help, Contains("Excludes: op1"));
}
-TEST(THelp, ExcludesSymmetric) {
+TEST_CASE("THelp: ExcludesSymmetric", "[help]") {
CLI::App app{"My prog"};
CLI::Option *op1 = app.add_flag("--op1");
@@ -380,10 +378,10 @@ TEST(THelp, ExcludesSymmetric) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Excludes: --op2"));
+ CHECK_THAT(help, Contains("Excludes: --op2"));
}
-TEST(THelp, ManualSetters) {
+TEST_CASE("THelp: ManualSetters", "[help]") {
CLI::App app{"My prog"};
@@ -392,35 +390,35 @@ TEST(THelp, ManualSetters) {
CLI::Option *op1 = app.add_option("--op", x);
op1->default_str("12");
op1->type_name("BIGGLES");
- EXPECT_EQ(x, 1);
+ CHECK(1 == x);
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("=12"));
- EXPECT_THAT(help, HasSubstr("BIGGLES"));
+ CHECK_THAT(help, Contains("=12"));
+ CHECK_THAT(help, Contains("BIGGLES"));
op1->default_val("14");
- EXPECT_EQ(x, 14);
+ CHECK(14 == x);
help = app.help();
- EXPECT_THAT(help, HasSubstr("=14"));
+ CHECK_THAT(help, Contains("=14"));
op1->default_val(12);
- EXPECT_EQ(x, 12);
+ CHECK(12 == x);
help = app.help();
- EXPECT_THAT(help, HasSubstr("=12"));
+ CHECK_THAT(help, Contains("=12"));
- EXPECT_TRUE(op1->get_run_callback_for_default());
+ CHECK(op1->get_run_callback_for_default());
op1->run_callback_for_default(false);
- EXPECT_FALSE(op1->get_run_callback_for_default());
+ CHECK(!op1->get_run_callback_for_default());
op1->default_val(18);
// x should not be modified in this case
- EXPECT_EQ(x, 12);
+ CHECK(12 == x);
help = app.help();
- EXPECT_THAT(help, HasSubstr("=18"));
+ CHECK_THAT(help, Contains("=18"));
}
-TEST(THelp, ManualSetterOverFunction) {
+TEST_CASE("THelp: ManualSetterOverFunction", "[help]") {
CLI::App app{"My prog"};
@@ -431,31 +429,31 @@ TEST(THelp, ManualSetterOverFunction) {
op1->default_str("12");
op1->type_name("BIGGLES");
op2->type_name("QUIGGLES");
- EXPECT_EQ(x, 1);
+ CHECK(1 == x);
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("=12"));
- EXPECT_THAT(help, HasSubstr("BIGGLES"));
- EXPECT_THAT(help, HasSubstr("QUIGGLES"));
- EXPECT_THAT(help, HasSubstr("{1,2}"));
+ CHECK_THAT(help, Contains("=12"));
+ CHECK_THAT(help, Contains("BIGGLES"));
+ CHECK_THAT(help, Contains("QUIGGLES"));
+ CHECK_THAT(help, Contains("{1,2}"));
}
-TEST(THelp, Subcom) {
+TEST_CASE("THelp: Subcom", "[help]") {
CLI::App app{"My prog"};
auto sub1 = app.add_subcommand("sub1");
app.add_subcommand("sub2");
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Usage: [OPTIONS] [SUBCOMMAND]"));
+ CHECK_THAT(help, Contains("Usage: [OPTIONS] [SUBCOMMAND]"));
app.require_subcommand();
help = app.help();
- EXPECT_THAT(help, HasSubstr("Usage: [OPTIONS] SUBCOMMAND"));
+ CHECK_THAT(help, Contains("Usage: [OPTIONS] SUBCOMMAND"));
help = sub1->help();
- EXPECT_THAT(help, HasSubstr("Usage: sub1"));
+ CHECK_THAT(help, Contains("Usage: sub1"));
char x[] = "./myprogram";
char y[] = "sub2";
@@ -464,10 +462,10 @@ TEST(THelp, Subcom) {
app.parse(static_cast<int>(args.size()), args.data());
help = app.help();
- EXPECT_THAT(help, HasSubstr("Usage: ./myprogram sub2"));
+ CHECK_THAT(help, Contains("Usage: ./myprogram sub2"));
}
-TEST(THelp, Subcom_alias) {
+TEST_CASE("THelp: Subcom_alias", "[help]") {
CLI::App app{"My prog"};
auto sub1 = app.add_subcommand("sub1", "Subcommand1 description test");
@@ -477,12 +475,12 @@ TEST(THelp, Subcom_alias) {
app.add_subcommand("sub2", "Subcommand2 description test");
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Usage: [OPTIONS] [SUBCOMMAND]"));
- EXPECT_THAT(help, HasSubstr("sub_alias1"));
- EXPECT_THAT(help, HasSubstr("sub_alias2"));
+ CHECK_THAT(help, Contains("Usage: [OPTIONS] [SUBCOMMAND]"));
+ CHECK_THAT(help, Contains("sub_alias1"));
+ CHECK_THAT(help, Contains("sub_alias2"));
}
-TEST(THelp, Subcom_alias_group) {
+TEST_CASE("THelp: Subcom_alias_group", "[help]") {
CLI::App app{"My prog"};
auto sub1 = app.add_subcommand("", "Subcommand1 description test");
@@ -492,12 +490,12 @@ TEST(THelp, Subcom_alias_group) {
app.add_subcommand("sub2", "Subcommand2 description test");
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Usage: [OPTIONS] [SUBCOMMAND]"));
- EXPECT_THAT(help, HasSubstr("sub_alias1"));
- EXPECT_THAT(help, HasSubstr("sub_alias2"));
+ CHECK_THAT(help, Contains("Usage: [OPTIONS] [SUBCOMMAND]"));
+ CHECK_THAT(help, Contains("sub_alias1"));
+ CHECK_THAT(help, Contains("sub_alias2"));
}
-TEST(THelp, MasterName) {
+TEST_CASE("THelp: MasterName", "[help]") {
CLI::App app{"My prog", "MyRealName"};
char x[] = "./myprogram";
@@ -505,10 +503,10 @@ TEST(THelp, MasterName) {
std::vector<char *> args = {x};
app.parse(static_cast<int>(args.size()), args.data());
- EXPECT_THAT(app.help(), HasSubstr("Usage: MyRealName"));
+ CHECK_THAT(app.help(), Contains("Usage: MyRealName"));
}
-TEST(THelp, IntDefaults) {
+TEST_CASE("THelp: IntDefaults", "[help]") {
CLI::App app{"My prog"};
int one{1}, two{2};
@@ -517,14 +515,14 @@ TEST(THelp, IntDefaults) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("--one"));
- EXPECT_THAT(help, HasSubstr("--set"));
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("=2"));
- EXPECT_THAT(help, HasSubstr("2,3,4"));
+ CHECK_THAT(help, Contains("--one"));
+ CHECK_THAT(help, Contains("--set"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("=2"));
+ CHECK_THAT(help, Contains("2,3,4"));
}
-TEST(THelp, SetLower) {
+TEST_CASE("THelp: SetLower", "[help]") {
CLI::App app{"My prog"};
app.option_defaults()->always_capture_default();
@@ -533,14 +531,14 @@ TEST(THelp, SetLower) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("--set"));
- EXPECT_THAT(help, HasSubstr("=One"));
- EXPECT_THAT(help, HasSubstr("oNe"));
- EXPECT_THAT(help, HasSubstr("twO"));
- EXPECT_THAT(help, HasSubstr("THREE"));
+ CHECK_THAT(help, Contains("--set"));
+ CHECK_THAT(help, Contains("=One"));
+ CHECK_THAT(help, Contains("oNe"));
+ CHECK_THAT(help, Contains("twO"));
+ CHECK_THAT(help, Contains("THREE"));
}
-TEST(THelp, OnlyOneHelp) {
+TEST_CASE("THelp: OnlyOneHelp", "[help]") {
CLI::App app{"My prog"};
// It is not supported to have more than one help flag, last one wins
@@ -548,10 +546,10 @@ TEST(THelp, OnlyOneHelp) {
app.set_help_flag("--yelp", "Alias for help");
std::vector<std::string> input{"--help"};
- EXPECT_THROW(app.parse(input), CLI::ExtrasError);
+ CHECK_THROWS_AS(app.parse(input), CLI::ExtrasError);
}
-TEST(THelp, MultiHelp) {
+TEST_CASE("THelp: MultiHelp", "[help]") {
CLI::App app{"My prog"};
// It is not supported to have more than one help flag, last one wins
@@ -559,10 +557,10 @@ TEST(THelp, MultiHelp) {
app.allow_windows_style_options();
std::vector<std::string> input{"/?"};
- EXPECT_THROW(app.parse(input), CLI::CallForHelp);
+ CHECK_THROWS_AS(app.parse(input), CLI::CallForHelp);
}
-TEST(THelp, OnlyOneAllHelp) {
+TEST_CASE("THelp: OnlyOneAllHelp", "[help]") {
CLI::App app{"My prog"};
// It is not supported to have more than one help flag, last one wins
@@ -570,37 +568,37 @@ TEST(THelp, OnlyOneAllHelp) {
app.set_help_all_flag("--yelp", "Alias for help");
std::vector<std::string> input{"--help-all"};
- EXPECT_THROW(app.parse(input), CLI::ExtrasError);
+ CHECK_THROWS_AS(app.parse(input), CLI::ExtrasError);
std::vector<std::string> input2{"--yelp"};
- EXPECT_THROW(app.parse(input2), CLI::CallForAllHelp);
+ CHECK_THROWS_AS(app.parse(input2), CLI::CallForAllHelp);
// Remove the flag
app.set_help_all_flag();
std::vector<std::string> input3{"--yelp"};
- EXPECT_THROW(app.parse(input3), CLI::ExtrasError);
+ CHECK_THROWS_AS(app.parse(input3), CLI::ExtrasError);
}
-TEST(THelp, RemoveHelp) {
+TEST_CASE("THelp: RemoveHelp", "[help]") {
CLI::App app{"My prog"};
app.set_help_flag();
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, Not(HasSubstr("-h,--help")));
- EXPECT_THAT(help, Not(HasSubstr("Options:")));
- EXPECT_THAT(help, HasSubstr("Usage:"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, !Contains("-h,--help"));
+ CHECK_THAT(help, !Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
std::vector<std::string> input{"--help"};
try {
app.parse(input);
} catch(const CLI::ParseError &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::ExtrasError), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::ExtrasError));
}
}
-TEST(THelp, RemoveOtherMethodHelp) {
+TEST_CASE("THelp: RemoveOtherMethodHelp", "[help]") {
CLI::App app{"My prog"};
// Don't do this. Just in case, let's make sure it works.
@@ -608,20 +606,20 @@ TEST(THelp, RemoveOtherMethodHelp) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, Not(HasSubstr("-h,--help")));
- EXPECT_THAT(help, Not(HasSubstr("Options:")));
- EXPECT_THAT(help, HasSubstr("Usage:"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, !Contains("-h,--help"));
+ CHECK_THAT(help, !Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
std::vector<std::string> input{"--help"};
try {
app.parse(input);
} catch(const CLI::ParseError &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::ExtrasError), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::ExtrasError));
}
}
-TEST(THelp, RemoveOtherMethodHelpAll) {
+TEST_CASE("THelp: RemoveOtherMethodHelpAll", "[help]") {
CLI::App app{"My prog"};
app.set_help_all_flag("--help-all");
@@ -630,61 +628,61 @@ TEST(THelp, RemoveOtherMethodHelpAll) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, Not(HasSubstr("--help-all")));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage:"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, !Contains("--help-all"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
std::vector<std::string> input{"--help-all"};
try {
app.parse(input);
} catch(const CLI::ParseError &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::ExtrasError), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::ExtrasError));
}
}
-TEST(THelp, NoHelp) {
+TEST_CASE("THelp: NoHelp", "[help]") {
CLI::App app{"My prog"};
app.set_help_flag();
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, Not(HasSubstr("-h,--help")));
- EXPECT_THAT(help, Not(HasSubstr("Options:")));
- EXPECT_THAT(help, HasSubstr("Usage:"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, !Contains("-h,--help"));
+ CHECK_THAT(help, !Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
std::vector<std::string> input{"--help"};
try {
app.parse(input);
} catch(const CLI::ParseError &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::ExtrasError), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::ExtrasError));
}
}
-TEST(THelp, CustomHelp) {
+TEST_CASE("THelp: CustomHelp", "[help]") {
CLI::App app{"My prog"};
CLI::Option *help_option = app.set_help_flag("--yelp", "display help and exit");
- EXPECT_EQ(app.get_help_ptr(), help_option);
+ CHECK(help_option == app.get_help_ptr());
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("My prog"));
- EXPECT_THAT(help, Not(HasSubstr("-h,--help")));
- EXPECT_THAT(help, HasSubstr("--yelp"));
- EXPECT_THAT(help, HasSubstr("Options:"));
- EXPECT_THAT(help, HasSubstr("Usage:"));
+ CHECK_THAT(help, Contains("My prog"));
+ CHECK_THAT(help, !Contains("-h,--help"));
+ CHECK_THAT(help, Contains("--yelp"));
+ CHECK_THAT(help, Contains("Options:"));
+ CHECK_THAT(help, Contains("Usage:"));
std::vector<std::string> input{"--yelp"};
try {
app.parse(input);
} catch(const CLI::CallForHelp &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::Success), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::Success));
}
}
-TEST(THelp, NextLineShouldBeAlignmentInMultilineDescription) {
+TEST_CASE("THelp: NextLineShouldBeAlignmentInMultilineDescription", "[help]") {
CLI::App app;
int i{0};
const std::string first{"first line"};
@@ -693,10 +691,10 @@ TEST(THelp, NextLineShouldBeAlignmentInMultilineDescription) {
const std::string help = app.help();
const auto width = app.get_formatter()->get_column_width();
- EXPECT_THAT(help, HasSubstr(first + "\n" + std::string(width, ' ') + second));
+ CHECK_THAT(help, Contains(first + "\n" + std::string(width, ' ') + second));
}
-TEST(THelp, NiceName) {
+TEST_CASE("THelp: NiceName", "[help]") {
CLI::App app;
int x{0};
@@ -704,23 +702,23 @@ TEST(THelp, NiceName) {
auto short_name = app.add_option("more,-x,-y", x);
auto positional = app.add_option("posit", x);
- EXPECT_EQ(long_name->get_name(), "--long");
- EXPECT_EQ(short_name->get_name(), "-x");
- EXPECT_EQ(positional->get_name(), "posit");
+ CHECK("--long" == long_name->get_name());
+ CHECK("-x" == short_name->get_name());
+ CHECK("posit" == positional->get_name());
}
-TEST(Exit, ErrorWithHelp) {
+TEST_CASE("Exit: ErrorWithHelp", "[help]") {
CLI::App app{"My prog"};
std::vector<std::string> input{"-h"};
try {
app.parse(input);
} catch(const CLI::CallForHelp &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::Success), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::Success));
}
}
-TEST(Exit, ErrorWithAllHelp) {
+TEST_CASE("Exit: ErrorWithAllHelp", "[help]") {
CLI::App app{"My prog"};
app.set_help_all_flag("--help-all", "All help");
@@ -728,33 +726,33 @@ TEST(Exit, ErrorWithAllHelp) {
try {
app.parse(input);
} catch(const CLI::CallForAllHelp &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::Success), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::Success));
}
}
-TEST(Exit, ErrorWithoutHelp) {
+TEST_CASE("Exit: ErrorWithoutHelp", "[help]") {
CLI::App app{"My prog"};
std::vector<std::string> input{"--none"};
try {
app.parse(input);
} catch(const CLI::ParseError &e) {
- EXPECT_EQ(static_cast<int>(CLI::ExitCodes::ExtrasError), e.get_exit_code());
+ CHECK(e.get_exit_code() == static_cast<int>(CLI::ExitCodes::ExtrasError));
}
}
-TEST(Exit, ExitCodes) {
+TEST_CASE("Exit: ExitCodes", "[help]") {
CLI::App app;
auto i = static_cast<int>(CLI::ExitCodes::ExtrasError);
- EXPECT_EQ(0, app.exit(CLI::Success()));
- EXPECT_EQ(0, app.exit(CLI::CallForHelp()));
- EXPECT_EQ(i, app.exit(CLI::ExtrasError({"Thing"})));
- EXPECT_EQ(42, app.exit(CLI::RuntimeError(42)));
- EXPECT_EQ(1, app.exit(CLI::RuntimeError())); // Not sure if a default here is a good thing
+ CHECK(app.exit(CLI::Success()) == 0);
+ CHECK(app.exit(CLI::CallForHelp()) == 0);
+ CHECK(app.exit(CLI::ExtrasError({"Thing"})) == i);
+ CHECK(app.exit(CLI::RuntimeError(42)) == 42);
+ CHECK(app.exit(CLI::RuntimeError()) == 1);
}
-struct CapturedHelp : public ::testing::Test {
+struct CapturedHelp {
CLI::App app{"My Test Program"};
std::stringstream out{};
std::stringstream err{};
@@ -767,113 +765,112 @@ struct CapturedHelp : public ::testing::Test {
}
};
-TEST_F(CapturedHelp, Successful) {
- EXPECT_EQ(run(CLI::Success()), 0);
- EXPECT_EQ(out.str(), "");
- EXPECT_EQ(err.str(), "");
+TEST_CASE_METHOD(CapturedHelp, "Successful", "[help]") {
+ CHECK(0 == run(CLI::Success()));
+ CHECK("" == out.str());
+ CHECK("" == err.str());
}
-TEST_F(CapturedHelp, JustAnError) {
- EXPECT_EQ(run(CLI::RuntimeError(42)), 42);
- EXPECT_EQ(out.str(), "");
- EXPECT_EQ(err.str(), "");
+TEST_CASE_METHOD(CapturedHelp, "JustAnError", "[help]") {
+ CHECK(42 == run(CLI::RuntimeError(42)));
+ CHECK("" == out.str());
+ CHECK("" == err.str());
}
-TEST_F(CapturedHelp, CallForHelp) {
- EXPECT_EQ(run(CLI::CallForHelp()), 0);
- EXPECT_EQ(out.str(), app.help());
- EXPECT_EQ(err.str(), "");
+TEST_CASE_METHOD(CapturedHelp, "CallForHelp", "[help]") {
+ CHECK(0 == run(CLI::CallForHelp()));
+ CHECK(app.help() == out.str());
+ CHECK("" == err.str());
}
-TEST_F(CapturedHelp, CallForAllHelp) {
- EXPECT_EQ(run(CLI::CallForAllHelp()), 0);
- EXPECT_EQ(out.str(), app.help("", CLI::AppFormatMode::All));
- EXPECT_EQ(err.str(), "");
+TEST_CASE_METHOD(CapturedHelp, "CallForAllHelp", "[help]") {
+ CHECK(0 == run(CLI::CallForAllHelp()));
+ CHECK(app.help("", CLI::AppFormatMode::All) == out.str());
+ CHECK("" == err.str());
}
-TEST_F(CapturedHelp, CallForAllHelpOutput) {
+TEST_CASE_METHOD(CapturedHelp, "CallForAllHelpOutput", "[help]") {
app.set_help_all_flag("--help-all", "Help all");
app.add_subcommand("one", "One description");
CLI::App *sub = app.add_subcommand("two");
sub->add_flag("--three");
- EXPECT_EQ(run(CLI::CallForAllHelp()), 0);
- EXPECT_EQ(out.str(), app.help("", CLI::AppFormatMode::All));
- EXPECT_EQ(err.str(), "");
- EXPECT_THAT(out.str(), HasSubstr("one"));
- EXPECT_THAT(out.str(), HasSubstr("two"));
- EXPECT_THAT(out.str(), HasSubstr("--three"));
-
- EXPECT_EQ(out.str(),
- "My Test Program\n"
- "Usage: [OPTIONS] [SUBCOMMAND]\n"
- "\n"
- "Options:\n"
- " -h,--help Print this help message and exit\n"
- " --help-all Help all\n"
- "\n"
- "Subcommands:\n"
- "one\n"
- " One description\n\n"
- "two\n"
- " Options:\n"
- " --three \n\n\n");
-}
-TEST_F(CapturedHelp, NewFormattedHelp) {
+ CHECK(0 == run(CLI::CallForAllHelp()));
+ CHECK(app.help("", CLI::AppFormatMode::All) == out.str());
+ CHECK("" == err.str());
+ CHECK_THAT(out.str(), Contains("one"));
+ CHECK_THAT(out.str(), Contains("two"));
+ CHECK_THAT(out.str(), Contains("--three"));
+
+ CHECK(out.str() == "My Test Program\n"
+ "Usage: [OPTIONS] [SUBCOMMAND]\n"
+ "\n"
+ "Options:\n"
+ " -h,--help Print this help message and exit\n"
+ " --help-all Help all\n"
+ "\n"
+ "Subcommands:\n"
+ "one\n"
+ " One description\n\n"
+ "two\n"
+ " Options:\n"
+ " --three \n\n\n");
+}
+TEST_CASE_METHOD(CapturedHelp, "NewFormattedHelp", "[help]") {
app.formatter_fn([](const CLI::App *, std::string, CLI::AppFormatMode) { return "New Help"; });
- EXPECT_EQ(run(CLI::CallForHelp()), 0);
- EXPECT_EQ(out.str(), "New Help");
- EXPECT_EQ(err.str(), "");
+ CHECK(0 == run(CLI::CallForHelp()));
+ CHECK("New Help" == out.str());
+ CHECK("" == err.str());
}
-TEST_F(CapturedHelp, NormalError) {
- EXPECT_EQ(run(CLI::ExtrasError({"Thing"})), static_cast<int>(CLI::ExitCodes::ExtrasError));
- EXPECT_EQ(out.str(), "");
- EXPECT_THAT(err.str(), HasSubstr("for more information"));
- EXPECT_THAT(err.str(), Not(HasSubstr("ExtrasError")));
- EXPECT_THAT(err.str(), HasSubstr("Thing"));
- EXPECT_THAT(err.str(), Not(HasSubstr(" or ")));
- EXPECT_THAT(err.str(), Not(HasSubstr("Usage")));
+TEST_CASE_METHOD(CapturedHelp, "NormalError", "[help]") {
+ CHECK(static_cast<int>(CLI::ExitCodes::ExtrasError) == run(CLI::ExtrasError({"Thing"})));
+ CHECK("" == out.str());
+ CHECK_THAT(err.str(), Contains("for more information"));
+ CHECK_THAT(err.str(), !Contains("ExtrasError"));
+ CHECK_THAT(err.str(), Contains("Thing"));
+ CHECK_THAT(err.str(), !Contains(" or "));
+ CHECK_THAT(err.str(), !Contains("Usage"));
}
-TEST_F(CapturedHelp, DoubleError) {
+TEST_CASE_METHOD(CapturedHelp, "DoubleError", "[help]") {
app.set_help_all_flag("--help-all");
- EXPECT_EQ(run(CLI::ExtrasError({"Thing"})), static_cast<int>(CLI::ExitCodes::ExtrasError));
- EXPECT_EQ(out.str(), "");
- EXPECT_THAT(err.str(), HasSubstr("for more information"));
- EXPECT_THAT(err.str(), HasSubstr(" --help "));
- EXPECT_THAT(err.str(), HasSubstr(" --help-all "));
- EXPECT_THAT(err.str(), HasSubstr(" or "));
- EXPECT_THAT(err.str(), Not(HasSubstr("ExtrasError")));
- EXPECT_THAT(err.str(), HasSubstr("Thing"));
- EXPECT_THAT(err.str(), Not(HasSubstr("Usage")));
-}
-
-TEST_F(CapturedHelp, AllOnlyError) {
+ CHECK(static_cast<int>(CLI::ExitCodes::ExtrasError) == run(CLI::ExtrasError({"Thing"})));
+ CHECK("" == out.str());
+ CHECK_THAT(err.str(), Contains("for more information"));
+ CHECK_THAT(err.str(), Contains(" --help "));
+ CHECK_THAT(err.str(), Contains(" --help-all "));
+ CHECK_THAT(err.str(), Contains(" or "));
+ CHECK_THAT(err.str(), !Contains("ExtrasError"));
+ CHECK_THAT(err.str(), Contains("Thing"));
+ CHECK_THAT(err.str(), !Contains("Usage"));
+}
+
+TEST_CASE_METHOD(CapturedHelp, "AllOnlyError", "[help]") {
app.set_help_all_flag("--help-all");
app.set_help_flag();
- EXPECT_EQ(run(CLI::ExtrasError({"Thing"})), static_cast<int>(CLI::ExitCodes::ExtrasError));
- EXPECT_EQ(out.str(), "");
- EXPECT_THAT(err.str(), HasSubstr("for more information"));
- EXPECT_THAT(err.str(), Not(HasSubstr(" --help ")));
- EXPECT_THAT(err.str(), HasSubstr(" --help-all "));
- EXPECT_THAT(err.str(), Not(HasSubstr(" or ")));
- EXPECT_THAT(err.str(), Not(HasSubstr("ExtrasError")));
- EXPECT_THAT(err.str(), HasSubstr("Thing"));
- EXPECT_THAT(err.str(), Not(HasSubstr("Usage")));
-}
-
-TEST_F(CapturedHelp, ReplacedError) {
+ CHECK(static_cast<int>(CLI::ExitCodes::ExtrasError) == run(CLI::ExtrasError({"Thing"})));
+ CHECK("" == out.str());
+ CHECK_THAT(err.str(), Contains("for more information"));
+ CHECK_THAT(err.str(), !Contains(" --help "));
+ CHECK_THAT(err.str(), Contains(" --help-all "));
+ CHECK_THAT(err.str(), !Contains(" or "));
+ CHECK_THAT(err.str(), !Contains("ExtrasError"));
+ CHECK_THAT(err.str(), Contains("Thing"));
+ CHECK_THAT(err.str(), !Contains("Usage"));
+}
+
+TEST_CASE_METHOD(CapturedHelp, "ReplacedError", "[help]") {
app.failure_message(CLI::FailureMessage::help);
- EXPECT_EQ(run(CLI::ExtrasError({"Thing"})), static_cast<int>(CLI::ExitCodes::ExtrasError));
- EXPECT_EQ(out.str(), "");
- EXPECT_THAT(err.str(), Not(HasSubstr("for more information")));
- EXPECT_THAT(err.str(), HasSubstr("ERROR: ExtrasError"));
- EXPECT_THAT(err.str(), HasSubstr("Thing"));
- EXPECT_THAT(err.str(), HasSubstr("Usage"));
+ CHECK(static_cast<int>(CLI::ExitCodes::ExtrasError) == run(CLI::ExtrasError({"Thing"})));
+ CHECK("" == out.str());
+ CHECK_THAT(err.str(), !Contains("for more information"));
+ CHECK_THAT(err.str(), Contains("ERROR: ExtrasError"));
+ CHECK_THAT(err.str(), Contains("Thing"));
+ CHECK_THAT(err.str(), Contains("Usage"));
}
// #87
-TEST(THelp, CustomDoubleOption) {
+TEST_CASE("THelp: CustomDoubleOption", "[help]") {
std::pair<int, double> custom_opt;
@@ -885,74 +882,74 @@ TEST(THelp, CustomDoubleOption) {
});
opt->type_name("INT FLOAT")->type_size(2);
- EXPECT_THAT(app.help(), Not(HasSubstr("x 2")));
+ CHECK_THAT(app.help(), !Contains("x 2"));
}
-TEST(THelp, CheckEmptyTypeName) {
+TEST_CASE("THelp: CheckEmptyTypeName", "[help]") {
CLI::App app;
auto opt = app.add_flag("-f,--flag");
std::string name = opt->get_type_name();
- EXPECT_TRUE(name.empty());
+ CHECK(name.empty());
}
-TEST(THelp, AccessDescription) {
+TEST_CASE("THelp: AccessDescription", "[help]") {
CLI::App app{"My description goes here"};
- EXPECT_EQ(app.get_description(), "My description goes here");
+ CHECK("My description goes here" == app.get_description());
}
-TEST(THelp, SetDescriptionAfterCreation) {
+TEST_CASE("THelp: SetDescriptionAfterCreation", "[help]") {
CLI::App app{""};
app.description("My description goes here");
- EXPECT_EQ(app.get_description(), "My description goes here");
- EXPECT_THAT(app.help(), HasSubstr("My description goes here"));
+ CHECK("My description goes here" == app.get_description());
+ CHECK_THAT(app.help(), Contains("My description goes here"));
}
-TEST(THelp, AccessOptionDescription) {
+TEST_CASE("THelp: AccessOptionDescription", "[help]") {
CLI::App app{};
int x{0};
auto opt = app.add_option("-a,--alpha", x, "My description goes here");
- EXPECT_EQ(opt->get_description(), "My description goes here");
+ CHECK("My description goes here" == opt->get_description());
}
-TEST(THelp, SetOptionDescriptionAfterCreation) {
+TEST_CASE("THelp: SetOptionDescriptionAfterCreation", "[help]") {
CLI::App app{};
int x{0};
auto opt = app.add_option("-a,--alpha", x);
opt->description("My description goes here");
- EXPECT_EQ(opt->get_description(), "My description goes here");
- EXPECT_THAT(app.help(), HasSubstr("My description goes here"));
+ CHECK("My description goes here" == opt->get_description());
+ CHECK_THAT(app.help(), Contains("My description goes here"));
}
-TEST(THelp, CleanNeeds) {
+TEST_CASE("THelp: CleanNeeds", "[help]") {
CLI::App app;
int x{0};
auto a_name = app.add_option("-a,--alpha", x);
app.add_option("-b,--boo", x)->needs(a_name);
- EXPECT_THAT(app.help(), Not(HasSubstr("Requires")));
- EXPECT_THAT(app.help(), Not(HasSubstr("Needs: -a,--alpha")));
- EXPECT_THAT(app.help(), HasSubstr("Needs: --alpha"));
+ CHECK_THAT(app.help(), !Contains("Requires"));
+ CHECK_THAT(app.help(), !Contains("Needs: -a,--alpha"));
+ CHECK_THAT(app.help(), Contains("Needs: --alpha"));
}
-TEST(THelp, RequiredPrintout) {
+TEST_CASE("THelp: RequiredPrintout", "[help]") {
CLI::App app;
int x{0};
app.add_option("-a,--alpha", x)->required();
- EXPECT_THAT(app.help(), HasSubstr(" REQUIRED"));
+ CHECK_THAT(app.help(), Contains(" REQUIRED"));
}
-TEST(THelp, GroupOrder) {
+TEST_CASE("THelp: GroupOrder", "[help]") {
CLI::App app;
app.add_flag("--one")->group("zee");
@@ -963,12 +960,12 @@ TEST(THelp, GroupOrder) {
auto zee_loc = help.find("zee");
auto aee_loc = help.find("aee");
- EXPECT_NE(zee_loc, std::string::npos);
- EXPECT_NE(aee_loc, std::string::npos);
- EXPECT_LT(zee_loc, aee_loc);
+ CHECK(std::string::npos != zee_loc);
+ CHECK(std::string::npos != aee_loc);
+ CHECK(aee_loc > zee_loc);
}
-TEST(THelp, ValidatorsText) {
+TEST_CASE("THelp: ValidatorsText", "[help]") {
CLI::App app;
std::string filename;
@@ -979,52 +976,52 @@ TEST(THelp, ValidatorsText) {
app.add_option("--f4", y)->check(CLI::Range(12));
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:FILE"));
- EXPECT_THAT(help, HasSubstr("INT in [1 - 4]"));
- EXPECT_THAT(help, HasSubstr("UINT:INT in [0 - 12]")); // Loses UINT
+ CHECK_THAT(help, Contains("TEXT:FILE"));
+ CHECK_THAT(help, Contains("INT in [1 - 4]"));
+ CHECK_THAT(help, Contains("UINT:INT in [0 - 12]"));
}
-TEST(THelp, ValidatorsTextCustom) {
+TEST_CASE("THelp: ValidatorsTextCustom", "[help]") {
CLI::App app;
std::string filename;
app.add_option("--f1", filename)->check(CLI::ExistingFile.description("Existing file"));
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("Existing file"));
+ CHECK_THAT(help, Contains("Existing file"));
}
-TEST(THelp, ValidatorsNonPathText) {
+TEST_CASE("THelp: ValidatorsNonPathText", "[help]") {
CLI::App app;
std::string filename;
app.add_option("--f2", filename)->check(CLI::NonexistentPath);
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:PATH"));
+ CHECK_THAT(help, Contains("TEXT:PATH"));
}
-TEST(THelp, ValidatorsDirText) {
+TEST_CASE("THelp: ValidatorsDirText", "[help]") {
CLI::App app;
std::string filename;
app.add_option("--f2", filename)->check(CLI::ExistingDirectory);
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:DIR"));
+ CHECK_THAT(help, Contains("TEXT:DIR"));
}
-TEST(THelp, ValidatorsPathText) {
+TEST_CASE("THelp: ValidatorsPathText", "[help]") {
CLI::App app;
std::string filename;
app.add_option("--f2", filename)->check(CLI::ExistingPath);
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:PATH"));
+ CHECK_THAT(help, Contains("TEXT:PATH"));
}
-TEST(THelp, CombinedValidatorsText) {
+TEST_CASE("THelp: CombinedValidatorsText", "[help]") {
CLI::App app;
std::string filename;
@@ -1034,12 +1031,12 @@ TEST(THelp, CombinedValidatorsText) {
// Can't programmatically tell!
// (Users can use ExistingPath, by the way)
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:(FILE) OR (DIR)"));
- EXPECT_THAT(help, Not(HasSubstr("PATH")));
+ CHECK_THAT(help, Contains("TEXT:(FILE) OR (DIR)"));
+ CHECK_THAT(help, !Contains("PATH"));
}
// Don't do this in real life, please
-TEST(THelp, CombinedValidatorsPathyText) {
+TEST_CASE("THelp: CombinedValidatorsPathyText", "[help]") {
CLI::App app;
std::string filename;
@@ -1047,12 +1044,12 @@ TEST(THelp, CombinedValidatorsPathyText) {
// Combining validators with the same type string is OK
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:"));
- EXPECT_THAT(help, HasSubstr("PATH"));
+ CHECK_THAT(help, Contains("TEXT:"));
+ CHECK_THAT(help, Contains("PATH"));
}
// Don't do this in real life, please (and transform does nothing here)
-TEST(THelp, CombinedValidatorsPathyTextAsTransform) {
+TEST_CASE("THelp: CombinedValidatorsPathyTextAsTransform", "[help]") {
CLI::App app;
std::string filename;
@@ -1060,11 +1057,11 @@ TEST(THelp, CombinedValidatorsPathyTextAsTransform) {
// Combining validators with the same type string is OK
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("TEXT:(PATH(existing)) OR (PATH"));
+ CHECK_THAT(help, Contains("TEXT:(PATH(existing)) OR (PATH"));
}
// #113 Part 2
-TEST(THelp, ChangingSet) {
+TEST_CASE("THelp: ChangingSet", "[help]") {
CLI::App app;
std::set<int> vals{1, 2, 3};
@@ -1073,19 +1070,19 @@ TEST(THelp, ChangingSet) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, Not(HasSubstr("4")));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, !Contains("4"));
vals.insert(4);
vals.erase(1);
help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("1")));
- EXPECT_THAT(help, HasSubstr("4"));
+ CHECK_THAT(help, !Contains("1"));
+ CHECK_THAT(help, Contains("4"));
}
-TEST(THelp, ChangingSetDefaulted) {
+TEST_CASE("THelp: ChangingSetDefaulted", "[help]") {
CLI::App app;
std::set<int> vals{1, 2, 3};
@@ -1094,19 +1091,19 @@ TEST(THelp, ChangingSetDefaulted) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, Not(HasSubstr("4")));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, !Contains("4"));
vals.insert(4);
vals.erase(1);
help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("1")));
- EXPECT_THAT(help, HasSubstr("4"));
+ CHECK_THAT(help, !Contains("1"));
+ CHECK_THAT(help, Contains("4"));
}
-TEST(THelp, ChangingCaselessSet) {
+TEST_CASE("THelp: ChangingCaselessSet", "[help]") {
CLI::App app;
std::set<std::string> vals{"1", "2", "3"};
@@ -1115,19 +1112,19 @@ TEST(THelp, ChangingCaselessSet) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, Not(HasSubstr("4")));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, !Contains("4"));
vals.insert("4");
vals.erase("1");
help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("1")));
- EXPECT_THAT(help, HasSubstr("4"));
+ CHECK_THAT(help, !Contains("1"));
+ CHECK_THAT(help, Contains("4"));
}
-TEST(THelp, ChangingCaselessSetDefaulted) {
+TEST_CASE("THelp: ChangingCaselessSetDefaulted", "[help]") {
CLI::App app;
app.option_defaults()->always_capture_default();
@@ -1137,21 +1134,21 @@ TEST(THelp, ChangingCaselessSetDefaulted) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, Not(HasSubstr("4")));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, !Contains("4"));
vals.insert("4");
vals.erase("1");
help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("1")));
- EXPECT_THAT(help, HasSubstr("4"));
+ CHECK_THAT(help, !Contains("1"));
+ CHECK_THAT(help, Contains("4"));
}
// New defaults tests (1.8)
-TEST(THelp, ChangingDefaults) {
+TEST_CASE("THelp: ChangingDefaults", "[help]") {
CLI::App app;
@@ -1164,10 +1161,10 @@ TEST(THelp, ChangingDefaults) {
x = {5, 6};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("INT=[3,4] ..."));
+ CHECK_THAT(help, Contains("INT=[3,4] ..."));
}
-TEST(THelp, ChangingDefaultsWithAutoCapture) {
+TEST_CASE("THelp: ChangingDefaultsWithAutoCapture", "[help]") {
CLI::App app;
app.option_defaults()->always_capture_default();
@@ -1178,10 +1175,10 @@ TEST(THelp, ChangingDefaultsWithAutoCapture) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("INT=[1,2] ..."));
+ CHECK_THAT(help, Contains("INT=[1,2] ..."));
}
-TEST(THelp, FunctionDefaultString) {
+TEST_CASE("THelp: FunctionDefaultString", "[help]") {
CLI::App app;
@@ -1193,44 +1190,44 @@ TEST(THelp, FunctionDefaultString) {
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("INT=Powerful"));
+ CHECK_THAT(help, Contains("INT=Powerful"));
}
-TEST(TVersion, simple_flag) {
+TEST_CASE("TVersion: simple_flag", "[help]") {
CLI::App app;
app.set_version_flag("-v,--version", "VERSION " CLI11_VERSION);
auto vers = app.version();
- EXPECT_THAT(vers, HasSubstr("VERSION"));
+ CHECK_THAT(vers, Contains("VERSION"));
app.set_version_flag();
- EXPECT_TRUE(app.version().empty());
+ CHECK(app.version().empty());
}
-TEST(TVersion, callback_flag) {
+TEST_CASE("TVersion: callback_flag", "[help]") {
CLI::App app;
app.set_version_flag("-v,--version", []() { return std::string("VERSION " CLI11_VERSION); });
auto vers = app.version();
- EXPECT_THAT(vers, HasSubstr("VERSION"));
+ CHECK_THAT(vers, Contains("VERSION"));
app.set_version_flag("-v", []() { return std::string("VERSION2 " CLI11_VERSION); });
vers = app.version();
- EXPECT_THAT(vers, HasSubstr("VERSION"));
+ CHECK_THAT(vers, Contains("VERSION"));
}
-TEST(TVersion, parse_throw) {
+TEST_CASE("TVersion: parse_throw", "[help]") {
CLI::App app;
app.set_version_flag("--version", CLI11_VERSION);
- EXPECT_THROW(app.parse("--version"), CLI::CallForVersion);
- EXPECT_THROW(app.parse("--version --arg2 5"), CLI::CallForVersion);
+ CHECK_THROWS_AS(app.parse("--version"), CLI::CallForVersion);
+ CHECK_THROWS_AS(app.parse("--version --arg2 5"), CLI::CallForVersion);
auto ptr = app.get_version_ptr();
@@ -1238,10 +1235,10 @@ TEST(TVersion, parse_throw) {
try {
app.parse("--Version");
} catch(const CLI::CallForVersion &v) {
- EXPECT_STREQ(v.what(), CLI11_VERSION);
- EXPECT_EQ(v.get_exit_code(), 0);
+ CHECK_THAT(CLI11_VERSION, Catch::Equals(v.what()));
+ CHECK(0 == v.get_exit_code());
const auto &appc = app;
auto cptr = appc.get_version_ptr();
- EXPECT_EQ(cptr->count(), 1U);
+ CHECK(1U == cptr->count());
}
}
diff --git a/packages/CLI11/tests/HelpersTest.cpp b/packages/CLI11/tests/HelpersTest.cpp
index 993b8a9f436e3916c3d37df22bd43bd904eedac9..0c032fbce389899324025f4c8759e328e5ffaea2 100644
--- a/packages/CLI11/tests/HelpersTest.cpp
+++ b/packages/CLI11/tests/HelpersTest.cpp
@@ -8,11 +8,11 @@
#include <array>
#include <atomic>
-#include <climits>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <fstream>
+#include <limits>
#include <map>
#include <string>
#include <tuple>
@@ -25,146 +25,146 @@ class Streamable {};
std::ostream &operator<<(std::ostream &out, const Streamable &) { return out << "Streamable"; }
-TEST(TypeTools, Streaming) {
+TEST_CASE("TypeTools: Streaming", "[helpers]") {
- EXPECT_EQ(CLI::detail::to_string(NotStreamable{}), "");
+ CHECK("" == CLI::detail::to_string(NotStreamable{}));
- EXPECT_EQ(CLI::detail::to_string(Streamable{}), "Streamable");
+ CHECK("Streamable" == CLI::detail::to_string(Streamable{}));
- EXPECT_EQ(CLI::detail::to_string(5), "5");
+ CHECK("5" == CLI::detail::to_string(5));
- EXPECT_EQ(CLI::detail::to_string("string"), std::string("string"));
- EXPECT_EQ(CLI::detail::to_string(std::string("string")), std::string("string"));
+ CHECK(std::string("string") == CLI::detail::to_string("string"));
+ CHECK(std::string("string") == CLI::detail::to_string(std::string("string")));
}
-TEST(TypeTools, tuple) {
- EXPECT_FALSE(CLI::detail::is_tuple_like<int>::value);
- EXPECT_FALSE(CLI::detail::is_tuple_like<std::vector<double>>::value);
+TEST_CASE("TypeTools: tuple", "[helpers]") {
+ CHECK_FALSE(CLI::detail::is_tuple_like<int>::value);
+ CHECK_FALSE(CLI::detail::is_tuple_like<std::vector<double>>::value);
auto v = CLI::detail::is_tuple_like<std::tuple<double, int>>::value;
- EXPECT_TRUE(v);
+ CHECK(v);
v = CLI::detail::is_tuple_like<std::tuple<double, double, double>>::value;
- EXPECT_TRUE(v);
+ CHECK(v);
}
-TEST(TypeTools, type_size) {
+TEST_CASE("TypeTools: type_size", "[helpers]") {
auto V = CLI::detail::type_count<int>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::type_count<void>::value;
- EXPECT_EQ(V, 0);
+ CHECK(0 == V);
V = CLI::detail::type_count<std::vector<double>>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::type_count<std::tuple<double, int>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count<std::tuple<std::string, double, int>>::value;
- EXPECT_EQ(V, 3);
+ CHECK(3 == V);
V = CLI::detail::type_count<std::array<std::string, 5>>::value;
- EXPECT_EQ(V, 5);
+ CHECK(5 == V);
V = CLI::detail::type_count<std::vector<std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count<std::tuple<std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count<std::tuple<int, std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 3);
+ CHECK(3 == V);
V = CLI::detail::type_count<std::tuple<std::pair<int, double>, std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 4);
+ CHECK(4 == V);
// maps
V = CLI::detail::type_count<std::map<int, std::pair<int, double>>>::value;
- EXPECT_EQ(V, 3);
+ CHECK(3 == V);
// three level tuples
V = CLI::detail::type_count<std::tuple<int, std::pair<int, std::tuple<int, double, std::string>>>>::value;
- EXPECT_EQ(V, 5);
+ CHECK(5 == V);
V = CLI::detail::type_count<std::pair<int, std::vector<int>>>::value;
- EXPECT_GE(V, CLI::detail::expected_max_vector_size);
+ CHECK(CLI::detail::expected_max_vector_size <= V);
V = CLI::detail::type_count<std::vector<std::vector<int>>>::value;
- EXPECT_EQ(V, CLI::detail::expected_max_vector_size);
+ CHECK(CLI::detail::expected_max_vector_size == V);
}
-TEST(TypeTools, type_size_min) {
+TEST_CASE("TypeTools: type_size_min", "[helpers]") {
auto V = CLI::detail::type_count_min<int>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::type_count_min<void>::value;
- EXPECT_EQ(V, 0);
+ CHECK(0 == V);
V = CLI::detail::type_count_min<std::vector<double>>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::type_count_min<std::tuple<double, int>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count_min<std::tuple<std::string, double, int>>::value;
- EXPECT_EQ(V, 3);
+ CHECK(3 == V);
V = CLI::detail::type_count_min<std::array<std::string, 5>>::value;
- EXPECT_EQ(V, 5);
+ CHECK(5 == V);
V = CLI::detail::type_count_min<std::vector<std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count_min<std::tuple<std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count_min<std::tuple<int, std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 3);
+ CHECK(3 == V);
V = CLI::detail::type_count_min<std::tuple<std::pair<int, double>, std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, 4);
+ CHECK(4 == V);
// maps
V = CLI::detail::type_count_min<std::map<int, std::pair<int, double>>>::value;
- EXPECT_EQ(V, 3);
+ CHECK(3 == V);
// three level tuples
V = CLI::detail::type_count_min<std::tuple<int, std::pair<int, std::tuple<int, double, std::string>>>>::value;
- EXPECT_EQ(V, 5);
+ CHECK(5 == V);
V = CLI::detail::type_count_min<std::pair<int, std::vector<int>>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
V = CLI::detail::type_count_min<std::vector<std::vector<int>>>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::type_count_min<std::vector<std::vector<std::pair<int, int>>>>::value;
- EXPECT_EQ(V, 2);
+ CHECK(2 == V);
}
-TEST(TypeTools, expected_count) {
+TEST_CASE("TypeTools: expected_count", "[helpers]") {
auto V = CLI::detail::expected_count<int>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::expected_count<void>::value;
- EXPECT_EQ(V, 0);
+ CHECK(0 == V);
V = CLI::detail::expected_count<std::vector<double>>::value;
- EXPECT_EQ(V, CLI::detail::expected_max_vector_size);
+ CHECK(CLI::detail::expected_max_vector_size == V);
V = CLI::detail::expected_count<std::tuple<double, int>>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::expected_count<std::tuple<std::string, double, int>>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::expected_count<std::array<std::string, 5>>::value;
- EXPECT_EQ(V, 1);
+ CHECK(1 == V);
V = CLI::detail::expected_count<std::vector<std::pair<std::string, double>>>::value;
- EXPECT_EQ(V, CLI::detail::expected_max_vector_size);
+ CHECK(CLI::detail::expected_max_vector_size == V);
}
-TEST(Split, SimpleByToken) {
+TEST_CASE("Split: SimpleByToken", "[helpers]") {
auto out = CLI::detail::split("one.two.three", '.');
- ASSERT_EQ(3u, out.size());
- EXPECT_EQ("one", out.at(0));
- EXPECT_EQ("two", out.at(1));
- EXPECT_EQ("three", out.at(2));
+ REQUIRE(out.size() == 3u);
+ CHECK(out.at(0) == "one");
+ CHECK(out.at(1) == "two");
+ CHECK(out.at(2) == "three");
}
-TEST(Split, Single) {
+TEST_CASE("Split: Single", "[helpers]") {
auto out = CLI::detail::split("one", '.');
- ASSERT_EQ(1u, out.size());
- EXPECT_EQ("one", out.at(0));
+ REQUIRE(out.size() == 1u);
+ CHECK(out.at(0) == "one");
}
-TEST(Split, Empty) {
+TEST_CASE("Split: Empty", "[helpers]") {
auto out = CLI::detail::split("", '.');
- ASSERT_EQ(1u, out.size());
- EXPECT_EQ("", out.at(0));
+ REQUIRE(out.size() == 1u);
+ CHECK(out.at(0) == "");
}
-TEST(String, InvalidName) {
- EXPECT_TRUE(CLI::detail::valid_name_string("valid"));
- EXPECT_FALSE(CLI::detail::valid_name_string("-invalid"));
- EXPECT_TRUE(CLI::detail::valid_name_string("va-li-d"));
- EXPECT_FALSE(CLI::detail::valid_name_string("vali&d"));
- EXPECT_TRUE(CLI::detail::valid_name_string("_valid"));
- EXPECT_FALSE(CLI::detail::valid_name_string("/valid"));
- EXPECT_TRUE(CLI::detail::valid_name_string("vali?d"));
- EXPECT_TRUE(CLI::detail::valid_name_string("@@@@"));
- EXPECT_TRUE(CLI::detail::valid_name_string("b@d2?"));
- EXPECT_TRUE(CLI::detail::valid_name_string("2vali?d"));
+TEST_CASE("String: InvalidName", "[helpers]") {
+ CHECK(CLI::detail::valid_name_string("valid"));
+ CHECK_FALSE(CLI::detail::valid_name_string("-invalid"));
+ CHECK(CLI::detail::valid_name_string("va-li-d"));
+ CHECK_FALSE(CLI::detail::valid_name_string("vali&d"));
+ CHECK(CLI::detail::valid_name_string("_valid"));
+ CHECK_FALSE(CLI::detail::valid_name_string("/valid"));
+ CHECK(CLI::detail::valid_name_string("vali?d"));
+ CHECK(CLI::detail::valid_name_string("@@@@"));
+ CHECK(CLI::detail::valid_name_string("b@d2?"));
+ CHECK(CLI::detail::valid_name_string("2vali?d"));
}
-TEST(StringTools, Modify) {
+TEST_CASE("StringTools: Modify", "[helpers]") {
int cnt{0};
std::string newString = CLI::detail::find_and_modify("======", "=", [&cnt](std::string &str, std::size_t index) {
if((++cnt) % 2 == 0) {
@@ -172,10 +172,10 @@ TEST(StringTools, Modify) {
}
return index + 1;
});
- EXPECT_EQ(newString, "=:=:=:");
+ CHECK("=:=:=:" == newString);
}
-TEST(StringTools, Modify2) {
+TEST_CASE("StringTools: Modify2", "[helpers]") {
std::string newString =
CLI::detail::find_and_modify("this is a string test", "is", [](std::string &str, std::size_t index) {
if((index > 1) && (str[index - 1] != ' ')) {
@@ -184,296 +184,296 @@ TEST(StringTools, Modify2) {
}
return index + 1;
});
- EXPECT_EQ(newString, "that is a string test");
+ CHECK("that is a string test" == newString);
}
-TEST(StringTools, Modify3) {
+TEST_CASE("StringTools: Modify3", "[helpers]") {
// this picks up 3 sets of 3 after the 'b' then collapses the new first set
std::string newString = CLI::detail::find_and_modify("baaaaaaaaaa", "aaa", [](std::string &str, std::size_t index) {
str.erase(index, 3);
str.insert(str.begin(), 'a');
return 0u;
});
- EXPECT_EQ(newString, "aba");
-}
-
-TEST(StringTools, flagValues) {
- EXPECT_EQ(CLI::detail::to_flag_value("0"), -1);
- EXPECT_EQ(CLI::detail::to_flag_value("t"), 1);
- EXPECT_EQ(CLI::detail::to_flag_value("1"), 1);
- EXPECT_EQ(CLI::detail::to_flag_value("6"), 6);
- EXPECT_EQ(CLI::detail::to_flag_value("-6"), -6);
- EXPECT_EQ(CLI::detail::to_flag_value("false"), -1);
- EXPECT_EQ(CLI::detail::to_flag_value("YES"), 1);
- EXPECT_THROW(CLI::detail::to_flag_value("frog"), std::invalid_argument);
- EXPECT_THROW(CLI::detail::to_flag_value("q"), std::invalid_argument);
- EXPECT_EQ(CLI::detail::to_flag_value("NO"), -1);
- EXPECT_EQ(CLI::detail::to_flag_value("475555233"), 475555233);
-}
-
-TEST(StringTools, Validation) {
- EXPECT_TRUE(CLI::detail::isalpha(""));
- EXPECT_TRUE(CLI::detail::isalpha("a"));
- EXPECT_TRUE(CLI::detail::isalpha("abcd"));
- EXPECT_FALSE(CLI::detail::isalpha("_"));
- EXPECT_FALSE(CLI::detail::isalpha("2"));
- EXPECT_FALSE(CLI::detail::isalpha("test test"));
- EXPECT_FALSE(CLI::detail::isalpha("test "));
- EXPECT_FALSE(CLI::detail::isalpha(" test"));
- EXPECT_FALSE(CLI::detail::isalpha("test2"));
-}
-
-TEST(Trim, Various) {
+ CHECK("aba" == newString);
+}
+
+TEST_CASE("StringTools: flagValues", "[helpers]") {
+ CHECK(-1 == CLI::detail::to_flag_value("0"));
+ CHECK(1 == CLI::detail::to_flag_value("t"));
+ CHECK(1 == CLI::detail::to_flag_value("1"));
+ CHECK(6 == CLI::detail::to_flag_value("6"));
+ CHECK(-6 == CLI::detail::to_flag_value("-6"));
+ CHECK(-1 == CLI::detail::to_flag_value("false"));
+ CHECK(1 == CLI::detail::to_flag_value("YES"));
+ CHECK_THROWS_AS(CLI::detail::to_flag_value("frog"), std::invalid_argument);
+ CHECK_THROWS_AS(CLI::detail::to_flag_value("q"), std::invalid_argument);
+ CHECK(-1 == CLI::detail::to_flag_value("NO"));
+ CHECK(475555233 == CLI::detail::to_flag_value("475555233"));
+}
+
+TEST_CASE("StringTools: Validation", "[helpers]") {
+ CHECK(CLI::detail::isalpha(""));
+ CHECK(CLI::detail::isalpha("a"));
+ CHECK(CLI::detail::isalpha("abcd"));
+ CHECK_FALSE(CLI::detail::isalpha("_"));
+ CHECK_FALSE(CLI::detail::isalpha("2"));
+ CHECK_FALSE(CLI::detail::isalpha("test test"));
+ CHECK_FALSE(CLI::detail::isalpha("test "));
+ CHECK_FALSE(CLI::detail::isalpha(" test"));
+ CHECK_FALSE(CLI::detail::isalpha("test2"));
+}
+
+TEST_CASE("Trim: Various", "[helpers]") {
std::string s1{" sdlfkj sdflk sd s "};
std::string a1{"sdlfkj sdflk sd s"};
CLI::detail::trim(s1);
- EXPECT_EQ(a1, s1);
+ CHECK(s1 == a1);
std::string s2{" a \t"};
CLI::detail::trim(s2);
- EXPECT_EQ("a", s2);
+ CHECK(s2 == "a");
std::string s3{" a \n"};
CLI::detail::trim(s3);
- EXPECT_EQ("a", s3);
+ CHECK(s3 == "a");
std::string s4{" a b "};
- EXPECT_EQ("a b", CLI::detail::trim(s4));
+ CHECK(CLI::detail::trim(s4) == "a b");
}
-TEST(Trim, VariousFilters) {
+TEST_CASE("Trim: VariousFilters", "[helpers]") {
std::string s1{" sdlfkj sdflk sd s "};
std::string a1{"sdlfkj sdflk sd s"};
CLI::detail::trim(s1, " ");
- EXPECT_EQ(a1, s1);
+ CHECK(s1 == a1);
std::string s2{" a \t"};
CLI::detail::trim(s2, " ");
- EXPECT_EQ("a \t", s2);
+ CHECK(s2 == "a \t");
std::string s3{"abdavda"};
CLI::detail::trim(s3, "a");
- EXPECT_EQ("bdavd", s3);
+ CHECK(s3 == "bdavd");
std::string s4{"abcabcabc"};
- EXPECT_EQ("cabcabc", CLI::detail::trim(s4, "ab"));
+ CHECK(CLI::detail::trim(s4, "ab") == "cabcabc");
}
-TEST(Trim, TrimCopy) {
+TEST_CASE("Trim: TrimCopy", "[helpers]") {
std::string orig{" cabc "};
std::string trimmed = CLI::detail::trim_copy(orig);
- EXPECT_EQ("cabc", trimmed);
- EXPECT_NE(orig, trimmed);
+ CHECK(trimmed == "cabc");
+ CHECK(trimmed != orig);
CLI::detail::trim(orig);
- EXPECT_EQ(trimmed, orig);
+ CHECK(orig == trimmed);
orig = "abcabcabc";
trimmed = CLI::detail::trim_copy(orig, "ab");
- EXPECT_EQ("cabcabc", trimmed);
- EXPECT_NE(orig, trimmed);
+ CHECK(trimmed == "cabcabc");
+ CHECK(trimmed != orig);
CLI::detail::trim(orig, "ab");
- EXPECT_EQ(trimmed, orig);
+ CHECK(orig == trimmed);
}
-TEST(Validators, FileExists) {
+TEST_CASE("Validators: FileExists", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK_FALSE(CLI::ExistingFile(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
+ CHECK(ok);
+ CHECK(CLI::ExistingFile(myfile).empty());
std::remove(myfile.c_str());
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK_FALSE(CLI::ExistingFile(myfile).empty());
}
-TEST(Validators, FileNotExists) {
+TEST_CASE("Validators: FileNotExists", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
- EXPECT_TRUE(CLI::NonexistentPath(myfile).empty());
+ CHECK(CLI::NonexistentPath(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_FALSE(CLI::NonexistentPath(myfile).empty());
+ CHECK(ok);
+ CHECK_FALSE(CLI::NonexistentPath(myfile).empty());
std::remove(myfile.c_str());
- EXPECT_TRUE(CLI::NonexistentPath(myfile).empty());
+ CHECK(CLI::NonexistentPath(myfile).empty());
}
-TEST(Validators, FileIsDir) {
+TEST_CASE("Validators: FileIsDir", "[helpers]") {
std::string mydir{"../tests"};
- EXPECT_NE(CLI::ExistingFile(mydir), "");
+ CHECK("" != CLI::ExistingFile(mydir));
}
-TEST(Validators, DirectoryExists) {
+TEST_CASE("Validators: DirectoryExists", "[helpers]") {
std::string mydir{"../tests"};
- EXPECT_EQ(CLI::ExistingDirectory(mydir), "");
+ CHECK("" == CLI::ExistingDirectory(mydir));
}
-TEST(Validators, DirectoryNotExists) {
+TEST_CASE("Validators: DirectoryNotExists", "[helpers]") {
std::string mydir{"nondirectory"};
- EXPECT_NE(CLI::ExistingDirectory(mydir), "");
+ CHECK("" != CLI::ExistingDirectory(mydir));
}
-TEST(Validators, DirectoryIsFile) {
+TEST_CASE("Validators: DirectoryIsFile", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
- EXPECT_TRUE(CLI::NonexistentPath(myfile).empty());
+ CHECK(CLI::NonexistentPath(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_FALSE(CLI::ExistingDirectory(myfile).empty());
+ CHECK(ok);
+ CHECK_FALSE(CLI::ExistingDirectory(myfile).empty());
std::remove(myfile.c_str());
- EXPECT_TRUE(CLI::NonexistentPath(myfile).empty());
+ CHECK(CLI::NonexistentPath(myfile).empty());
}
-TEST(Validators, PathExistsDir) {
+TEST_CASE("Validators: PathExistsDir", "[helpers]") {
std::string mydir{"../tests"};
- EXPECT_EQ(CLI::ExistingPath(mydir), "");
+ CHECK("" == CLI::ExistingPath(mydir));
}
-TEST(Validators, PathExistsFile) {
+TEST_CASE("Validators: PathExistsFile", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
- EXPECT_FALSE(CLI::ExistingPath(myfile).empty());
+ CHECK_FALSE(CLI::ExistingPath(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_TRUE(CLI::ExistingPath(myfile).empty());
+ CHECK(ok);
+ CHECK(CLI::ExistingPath(myfile).empty());
std::remove(myfile.c_str());
- EXPECT_FALSE(CLI::ExistingPath(myfile).empty());
+ CHECK_FALSE(CLI::ExistingPath(myfile).empty());
}
-TEST(Validators, PathNotExistsDir) {
+TEST_CASE("Validators: PathNotExistsDir", "[helpers]") {
std::string mydir{"nonpath"};
- EXPECT_NE(CLI::ExistingPath(mydir), "");
+ CHECK("" != CLI::ExistingPath(mydir));
}
-TEST(Validators, IPValidate1) {
+TEST_CASE("Validators: IPValidate1", "[helpers]") {
std::string ip = "1.1.1.1";
- EXPECT_TRUE(CLI::ValidIPV4(ip).empty());
+ CHECK(CLI::ValidIPV4(ip).empty());
ip = "224.255.0.1";
- EXPECT_TRUE(CLI::ValidIPV4(ip).empty());
+ CHECK(CLI::ValidIPV4(ip).empty());
ip = "-1.255.0.1";
- EXPECT_FALSE(CLI::ValidIPV4(ip).empty());
+ CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "1.256.0.1";
- EXPECT_FALSE(CLI::ValidIPV4(ip).empty());
+ CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "1.256.0.1";
- EXPECT_FALSE(CLI::ValidIPV4(ip).empty());
+ CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "aaa";
- EXPECT_FALSE(CLI::ValidIPV4(ip).empty());
+ CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "1.2.3.abc";
- EXPECT_FALSE(CLI::ValidIPV4(ip).empty());
+ CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "11.22";
- EXPECT_FALSE(CLI::ValidIPV4(ip).empty());
+ CHECK_FALSE(CLI::ValidIPV4(ip).empty());
}
-TEST(Validators, PositiveValidator) {
+TEST_CASE("Validators: PositiveValidator", "[helpers]") {
std::string num = "1.1.1.1";
- EXPECT_FALSE(CLI::PositiveNumber(num).empty());
+ CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "1";
- EXPECT_TRUE(CLI::PositiveNumber(num).empty());
+ CHECK(CLI::PositiveNumber(num).empty());
num = "10000";
- EXPECT_TRUE(CLI::PositiveNumber(num).empty());
+ CHECK(CLI::PositiveNumber(num).empty());
num = "0";
- EXPECT_FALSE(CLI::PositiveNumber(num).empty());
+ CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "+0.5";
- EXPECT_TRUE(CLI::PositiveNumber(num).empty());
+ CHECK(CLI::PositiveNumber(num).empty());
num = "-1";
- EXPECT_FALSE(CLI::PositiveNumber(num).empty());
+ CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "-1.5";
- EXPECT_FALSE(CLI::PositiveNumber(num).empty());
+ CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "a";
- EXPECT_FALSE(CLI::PositiveNumber(num).empty());
+ CHECK_FALSE(CLI::PositiveNumber(num).empty());
}
-TEST(Validators, NonNegativeValidator) {
+TEST_CASE("Validators: NonNegativeValidator", "[helpers]") {
std::string num = "1.1.1.1";
- EXPECT_FALSE(CLI::NonNegativeNumber(num).empty());
+ CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
num = "1";
- EXPECT_TRUE(CLI::NonNegativeNumber(num).empty());
+ CHECK(CLI::NonNegativeNumber(num).empty());
num = "10000";
- EXPECT_TRUE(CLI::NonNegativeNumber(num).empty());
+ CHECK(CLI::NonNegativeNumber(num).empty());
num = "0";
- EXPECT_TRUE(CLI::NonNegativeNumber(num).empty());
+ CHECK(CLI::NonNegativeNumber(num).empty());
num = "+0.5";
- EXPECT_TRUE(CLI::NonNegativeNumber(num).empty());
+ CHECK(CLI::NonNegativeNumber(num).empty());
num = "-1";
- EXPECT_FALSE(CLI::NonNegativeNumber(num).empty());
+ CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
num = "-1.5";
- EXPECT_FALSE(CLI::NonNegativeNumber(num).empty());
+ CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
num = "a";
- EXPECT_FALSE(CLI::NonNegativeNumber(num).empty());
+ CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
}
-TEST(Validators, NumberValidator) {
+TEST_CASE("Validators: NumberValidator", "[helpers]") {
std::string num = "1.1.1.1";
- EXPECT_FALSE(CLI::Number(num).empty());
+ CHECK_FALSE(CLI::Number(num).empty());
num = "1.7";
- EXPECT_TRUE(CLI::Number(num).empty());
+ CHECK(CLI::Number(num).empty());
num = "10000";
- EXPECT_TRUE(CLI::Number(num).empty());
+ CHECK(CLI::Number(num).empty());
num = "-0.000";
- EXPECT_TRUE(CLI::Number(num).empty());
+ CHECK(CLI::Number(num).empty());
num = "+1.55";
- EXPECT_TRUE(CLI::Number(num).empty());
+ CHECK(CLI::Number(num).empty());
num = "a";
- EXPECT_FALSE(CLI::Number(num).empty());
+ CHECK_FALSE(CLI::Number(num).empty());
}
-TEST(Validators, CombinedAndRange) {
+TEST_CASE("Validators: CombinedAndRange", "[helpers]") {
auto crange = CLI::Range(0, 12) & CLI::Range(4, 16);
- EXPECT_TRUE(crange("4").empty());
- EXPECT_TRUE(crange("12").empty());
- EXPECT_TRUE(crange("7").empty());
+ CHECK(crange("4").empty());
+ CHECK(crange("12").empty());
+ CHECK(crange("7").empty());
- EXPECT_FALSE(crange("-2").empty());
- EXPECT_FALSE(crange("2").empty());
- EXPECT_FALSE(crange("15").empty());
- EXPECT_FALSE(crange("16").empty());
- EXPECT_FALSE(crange("18").empty());
+ CHECK_FALSE(crange("-2").empty());
+ CHECK_FALSE(crange("2").empty());
+ CHECK_FALSE(crange("15").empty());
+ CHECK_FALSE(crange("16").empty());
+ CHECK_FALSE(crange("18").empty());
}
-TEST(Validators, CombinedOrRange) {
+TEST_CASE("Validators: CombinedOrRange", "[helpers]") {
auto crange = CLI::Range(0, 4) | CLI::Range(8, 12);
- EXPECT_FALSE(crange("-2").empty());
- EXPECT_TRUE(crange("2").empty());
- EXPECT_FALSE(crange("5").empty());
- EXPECT_TRUE(crange("8").empty());
- EXPECT_TRUE(crange("12").empty());
- EXPECT_FALSE(crange("16").empty());
+ CHECK_FALSE(crange("-2").empty());
+ CHECK(crange("2").empty());
+ CHECK_FALSE(crange("5").empty());
+ CHECK(crange("8").empty());
+ CHECK(crange("12").empty());
+ CHECK_FALSE(crange("16").empty());
}
-TEST(Validators, CombinedPaths) {
+TEST_CASE("Validators: CombinedPaths", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK_FALSE(CLI::ExistingFile(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
+ CHECK(ok);
std::string dir{"../tests"};
std::string notpath{"nondirectory"};
auto path_or_dir = CLI::ExistingPath | CLI::ExistingDirectory;
- EXPECT_TRUE(path_or_dir(dir).empty());
- EXPECT_TRUE(path_or_dir(myfile).empty());
- EXPECT_FALSE(path_or_dir(notpath).empty());
+ CHECK(path_or_dir(dir).empty());
+ CHECK(path_or_dir(myfile).empty());
+ CHECK_FALSE(path_or_dir(notpath).empty());
auto file_or_dir = CLI::ExistingFile | CLI::ExistingDirectory;
- EXPECT_TRUE(file_or_dir(dir).empty());
- EXPECT_TRUE(file_or_dir(myfile).empty());
- EXPECT_FALSE(file_or_dir(notpath).empty());
+ CHECK(file_or_dir(dir).empty());
+ CHECK(file_or_dir(myfile).empty());
+ CHECK_FALSE(file_or_dir(notpath).empty());
auto path_and_dir = CLI::ExistingPath & CLI::ExistingDirectory;
- EXPECT_TRUE(path_and_dir(dir).empty());
- EXPECT_FALSE(path_and_dir(myfile).empty());
- EXPECT_FALSE(path_and_dir(notpath).empty());
+ CHECK(path_and_dir(dir).empty());
+ CHECK_FALSE(path_and_dir(myfile).empty());
+ CHECK_FALSE(path_and_dir(notpath).empty());
auto path_and_file = CLI::ExistingFile & CLI::ExistingDirectory;
- EXPECT_FALSE(path_and_file(dir).empty());
- EXPECT_FALSE(path_and_file(myfile).empty());
- EXPECT_FALSE(path_and_file(notpath).empty());
+ CHECK_FALSE(path_and_file(dir).empty());
+ CHECK_FALSE(path_and_file(myfile).empty());
+ CHECK_FALSE(path_and_file(notpath).empty());
std::remove(myfile.c_str());
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK_FALSE(CLI::ExistingFile(myfile).empty());
}
-TEST(Validators, ProgramNameSplit) {
+TEST_CASE("Validators: ProgramNameSplit", "[helpers]") {
TempFile myfile{"program_name1.exe"};
{
std::ofstream out{myfile};
@@ -481,8 +481,8 @@ TEST(Validators, ProgramNameSplit) {
}
auto res =
CLI::detail::split_program_name(std::string("./") + std::string(myfile) + " this is a bunch of extra stuff ");
- EXPECT_EQ(res.first, std::string("./") + std::string(myfile));
- EXPECT_EQ(res.second, "this is a bunch of extra stuff");
+ CHECK(std::string("./") + std::string(myfile) == res.first);
+ CHECK("this is a bunch of extra stuff" == res.second);
TempFile myfile2{"program name1.exe"};
{
@@ -491,257 +491,257 @@ TEST(Validators, ProgramNameSplit) {
}
res = CLI::detail::split_program_name(std::string(" ") + std::string("./") + std::string(myfile2) +
" this is a bunch of extra stuff ");
- EXPECT_EQ(res.first, std::string("./") + std::string(myfile2));
- EXPECT_EQ(res.second, "this is a bunch of extra stuff");
+ CHECK(std::string("./") + std::string(myfile2) == res.first);
+ CHECK("this is a bunch of extra stuff" == res.second);
res = CLI::detail::split_program_name("./program_name this is a bunch of extra stuff ");
- EXPECT_EQ(res.first, "./program_name"); // test sectioning of first argument even if it can't detect the file
- EXPECT_EQ(res.second, "this is a bunch of extra stuff");
+ CHECK("./program_name" == res.first);
+ CHECK("this is a bunch of extra stuff" == res.second);
res = CLI::detail::split_program_name(std::string(" ./") + std::string(myfile) + " ");
- EXPECT_EQ(res.first, std::string("./") + std::string(myfile));
- EXPECT_TRUE(res.second.empty());
+ CHECK(std::string("./") + std::string(myfile) == res.first);
+ CHECK(res.second.empty());
}
-TEST(CheckedMultiply, Int) {
+TEST_CASE("CheckedMultiply: Int", "[helpers]") {
int a{10};
int b{-20};
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, -200);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(-200 == a);
a = 0;
b = -20;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, 0);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(0 == a);
a = 20;
b = 0;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, 0);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(0 == a);
a = std::numeric_limits<int>::max();
b = 1;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::max());
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::max() == a);
a = std::numeric_limits<int>::max();
b = 2;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::max());
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::max() == a);
a = std::numeric_limits<int>::max();
b = -1;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, -std::numeric_limits<int>::max());
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(-std::numeric_limits<int>::max() == a);
a = std::numeric_limits<int>::max();
b = std::numeric_limits<int>::max();
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::max());
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::max() == a);
a = std::numeric_limits<int>::min();
b = std::numeric_limits<int>::max();
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::min());
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::min() == a);
a = std::numeric_limits<int>::min();
b = 1;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::min());
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::min() == a);
a = std::numeric_limits<int>::min();
b = -1;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::min());
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::min() == a);
b = std::numeric_limits<int>::min();
a = -1;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, -1);
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(-1 == a);
a = std::numeric_limits<int>::min() / 100;
b = 99;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::min() / 100 * 99);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::min() / 100 * 99 == a);
a = std::numeric_limits<int>::min() / 100;
b = -101;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<int>::min() / 100);
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<int>::min() / 100 == a);
a = 2;
b = std::numeric_limits<int>::min() / 2;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(CLI::detail::checked_multiply(a, b));
a = std::numeric_limits<int>::min() / 2;
b = 2;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(CLI::detail::checked_multiply(a, b));
a = 4;
b = std::numeric_limits<int>::min() / 4;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(CLI::detail::checked_multiply(a, b));
a = 48;
b = std::numeric_limits<int>::min() / 48;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(CLI::detail::checked_multiply(a, b));
}
-TEST(CheckedMultiply, SizeT) {
+TEST_CASE("CheckedMultiply: SizeT", "[helpers]") {
std::size_t a = 10;
std::size_t b = 20;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, 200u);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(200u == a);
a = 0u;
b = 20u;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, 0u);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(0u == a);
a = 20u;
b = 0u;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, 0u);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(0u == a);
a = std::numeric_limits<std::size_t>::max();
b = 1u;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<std::size_t>::max());
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<std::size_t>::max() == a);
a = std::numeric_limits<std::size_t>::max();
b = 2u;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<std::size_t>::max());
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<std::size_t>::max() == a);
a = std::numeric_limits<std::size_t>::max();
b = std::numeric_limits<std::size_t>::max();
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<std::size_t>::max());
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<std::size_t>::max() == a);
a = std::numeric_limits<std::size_t>::max() / 100;
b = 99u;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_EQ(a, std::numeric_limits<std::size_t>::max() / 100u * 99u);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<std::size_t>::max() / 100u * 99u == a);
}
-TEST(CheckedMultiply, Float) {
+TEST_CASE("CheckedMultiply: Float", "[helpers]") {
float a{10.0F};
float b{20.0F};
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, 200);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(200 == Approx(a));
a = 0.0F;
b = 20.0F;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, 0);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(0 == Approx(a));
a = INFINITY;
b = 20.0F;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, INFINITY);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(INFINITY == Approx(a));
a = 2.0F;
b = -INFINITY;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, -INFINITY);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(-INFINITY == Approx(a));
a = std::numeric_limits<float>::max() / 100.0F;
b = 1.0F;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, std::numeric_limits<float>::max() / 100.0F);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<float>::max() / 100.0F == Approx(a));
a = std::numeric_limits<float>::max() / 100.0F;
b = 99.0F;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, std::numeric_limits<float>::max() / 100.0F * 99.0F);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<float>::max() / 100.0F * 99.0F == Approx(a));
a = std::numeric_limits<float>::max() / 100.0F;
b = 101;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, std::numeric_limits<float>::max() / 100.0F);
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<float>::max() / 100.0F == Approx(a));
a = std::numeric_limits<float>::max() / 100.0F;
b = -99;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, std::numeric_limits<float>::max() / 100.0F * -99.0F);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<float>::max() / 100.0F * -99.0F == Approx(a));
a = std::numeric_limits<float>::max() / 100.0F;
b = -101;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_FLOAT_EQ(a, std::numeric_limits<float>::max() / 100.0F);
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<float>::max() / 100.0F == Approx(a));
}
-TEST(CheckedMultiply, Double) {
+TEST_CASE("CheckedMultiply: Double", "[helpers]") {
double a{10.0F};
double b{20.0F};
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, 200);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(200 == Approx(a));
a = 0;
b = 20;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, 0);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(0 == Approx(a));
a = INFINITY;
b = 20;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, INFINITY);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(INFINITY == Approx(a));
a = 2;
b = -INFINITY;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, -INFINITY);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(-INFINITY == Approx(a));
a = std::numeric_limits<double>::max() / 100;
b = 1;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, std::numeric_limits<double>::max() / 100);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<double>::max() / 100 == Approx(a));
a = std::numeric_limits<double>::max() / 100;
b = 99;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, std::numeric_limits<double>::max() / 100 * 99);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<double>::max() / 100 * 99 == Approx(a));
a = std::numeric_limits<double>::max() / 100;
b = 101;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, std::numeric_limits<double>::max() / 100);
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<double>::max() / 100 == Approx(a));
a = std::numeric_limits<double>::max() / 100;
b = -99;
- ASSERT_TRUE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, std::numeric_limits<double>::max() / 100 * -99);
+ REQUIRE(CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<double>::max() / 100 * -99 == Approx(a));
a = std::numeric_limits<double>::max() / 100;
b = -101;
- ASSERT_FALSE(CLI::detail::checked_multiply(a, b));
- ASSERT_DOUBLE_EQ(a, std::numeric_limits<double>::max() / 100);
+ REQUIRE(!CLI::detail::checked_multiply(a, b));
+ REQUIRE(std::numeric_limits<double>::max() / 100 == Approx(a));
}
// Yes, this is testing an app_helper :)
-TEST(AppHelper, TempfileCreated) {
+TEST_CASE("AppHelper: TempfileCreated", "[helpers]") {
std::string name = "TestFileNotUsed.txt";
{
TempFile myfile{name};
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK_FALSE(CLI::ExistingFile(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
- EXPECT_TRUE(CLI::ExistingFile(name).empty());
- EXPECT_THROW({ TempFile otherfile(name); }, std::runtime_error);
+ CHECK(ok);
+ CHECK(CLI::ExistingFile(name).empty());
+ CHECK_THROWS_AS([&]() { TempFile otherfile(name); }(), std::runtime_error);
}
- EXPECT_FALSE(CLI::ExistingFile(name).empty());
+ CHECK_FALSE(CLI::ExistingFile(name).empty());
}
-TEST(AppHelper, TempfileNotCreated) {
+TEST_CASE("AppHelper: TempfileNotCreated", "[helpers]") {
std::string name = "TestFileNotUsed.txt";
{
TempFile myfile{name};
- EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
+ CHECK_FALSE(CLI::ExistingFile(myfile).empty());
}
- EXPECT_FALSE(CLI::ExistingFile(name).empty());
+ CHECK_FALSE(CLI::ExistingFile(name).empty());
}
-TEST(AppHelper, Ofstream) {
+TEST_CASE("AppHelper: Ofstream", "[helpers]") {
std::string name = "TestFileNotUsed.txt";
{
@@ -752,174 +752,178 @@ TEST(AppHelper, Ofstream) {
out << "this is output" << std::endl;
}
- EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
+ CHECK(CLI::ExistingFile(myfile).empty());
}
- EXPECT_FALSE(CLI::ExistingFile(name).empty());
+ CHECK_FALSE(CLI::ExistingFile(name).empty());
}
-TEST(Split, StringList) {
+TEST_CASE("Split: StringList", "[helpers]") {
std::vector<std::string> results{"a", "long", "--lone", "-q"};
- EXPECT_EQ(results, CLI::detail::split_names("a,long,--lone,-q"));
- EXPECT_EQ(results, CLI::detail::split_names(" a, long, --lone, -q"));
- EXPECT_EQ(results, CLI::detail::split_names(" a , long , --lone , -q "));
- EXPECT_EQ(results, CLI::detail::split_names(" a , long , --lone , -q "));
+ CHECK(CLI::detail::split_names("a,long,--lone,-q") == results);
+ CHECK(CLI::detail::split_names(" a, long, --lone, -q") == results);
+ CHECK(CLI::detail::split_names(" a , long , --lone , -q ") == results);
+ CHECK(CLI::detail::split_names(" a , long , --lone , -q ") == results);
- EXPECT_EQ(std::vector<std::string>({"one"}), CLI::detail::split_names("one"));
+ CHECK(CLI::detail::split_names("one") == std::vector<std::string>({"one"}));
}
-TEST(RegEx, Shorts) {
+TEST_CASE("RegEx: Shorts", "[helpers]") {
std::string name, value;
- EXPECT_TRUE(CLI::detail::split_short("-a", name, value));
- EXPECT_EQ("a", name);
- EXPECT_EQ("", value);
+ CHECK(CLI::detail::split_short("-a", name, value));
+ CHECK(name == "a");
+ CHECK(value == "");
- EXPECT_TRUE(CLI::detail::split_short("-B", name, value));
- EXPECT_EQ("B", name);
- EXPECT_EQ("", value);
+ CHECK(CLI::detail::split_short("-B", name, value));
+ CHECK(name == "B");
+ CHECK(value == "");
- EXPECT_TRUE(CLI::detail::split_short("-cc", name, value));
- EXPECT_EQ("c", name);
- EXPECT_EQ("c", value);
+ CHECK(CLI::detail::split_short("-cc", name, value));
+ CHECK(name == "c");
+ CHECK(value == "c");
- EXPECT_TRUE(CLI::detail::split_short("-simple", name, value));
- EXPECT_EQ("s", name);
- EXPECT_EQ("imple", value);
+ CHECK(CLI::detail::split_short("-simple", name, value));
+ CHECK(name == "s");
+ CHECK(value == "imple");
- EXPECT_FALSE(CLI::detail::split_short("--a", name, value));
- EXPECT_FALSE(CLI::detail::split_short("--thing", name, value));
- EXPECT_FALSE(CLI::detail::split_short("--", name, value));
- EXPECT_FALSE(CLI::detail::split_short("something", name, value));
- EXPECT_FALSE(CLI::detail::split_short("s", name, value));
+ CHECK_FALSE(CLI::detail::split_short("--a", name, value));
+ CHECK_FALSE(CLI::detail::split_short("--thing", name, value));
+ CHECK_FALSE(CLI::detail::split_short("--", name, value));
+ CHECK_FALSE(CLI::detail::split_short("something", name, value));
+ CHECK_FALSE(CLI::detail::split_short("s", name, value));
}
-TEST(RegEx, Longs) {
+TEST_CASE("RegEx: Longs", "[helpers]") {
std::string name, value;
- EXPECT_TRUE(CLI::detail::split_long("--a", name, value));
- EXPECT_EQ("a", name);
- EXPECT_EQ("", value);
+ CHECK(CLI::detail::split_long("--a", name, value));
+ CHECK(name == "a");
+ CHECK(value == "");
- EXPECT_TRUE(CLI::detail::split_long("--thing", name, value));
- EXPECT_EQ("thing", name);
- EXPECT_EQ("", value);
+ CHECK(CLI::detail::split_long("--thing", name, value));
+ CHECK(name == "thing");
+ CHECK(value == "");
- EXPECT_TRUE(CLI::detail::split_long("--some=thing", name, value));
- EXPECT_EQ("some", name);
- EXPECT_EQ("thing", value);
+ CHECK(CLI::detail::split_long("--some=thing", name, value));
+ CHECK(name == "some");
+ CHECK(value == "thing");
- EXPECT_FALSE(CLI::detail::split_long("-a", name, value));
- EXPECT_FALSE(CLI::detail::split_long("-things", name, value));
- EXPECT_FALSE(CLI::detail::split_long("Q", name, value));
- EXPECT_FALSE(CLI::detail::split_long("--", name, value));
+ CHECK_FALSE(CLI::detail::split_long("-a", name, value));
+ CHECK_FALSE(CLI::detail::split_long("-things", name, value));
+ CHECK_FALSE(CLI::detail::split_long("Q", name, value));
+ CHECK_FALSE(CLI::detail::split_long("--", name, value));
}
-TEST(RegEx, SplittingNew) {
+TEST_CASE("RegEx: SplittingNew", "[helpers]") {
std::vector<std::string> shorts;
std::vector<std::string> longs;
std::string pname;
- EXPECT_NO_THROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"--long", "-s", "-q", "--also-long"}));
- EXPECT_EQ(std::vector<std::string>({"long", "also-long"}), longs);
- EXPECT_EQ(std::vector<std::string>({"s", "q"}), shorts);
- EXPECT_EQ("", pname);
+ CHECK_NOTHROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"--long", "-s", "-q", "--also-long"}));
+ CHECK(longs == std::vector<std::string>({"long", "also-long"}));
+ CHECK(shorts == std::vector<std::string>({"s", "q"}));
+ CHECK(pname == "");
- EXPECT_NO_THROW(std::tie(shorts, longs, pname) =
- CLI::detail::get_names({"--long", "", "-s", "-q", "", "--also-long"}));
- EXPECT_EQ(std::vector<std::string>({"long", "also-long"}), longs);
- EXPECT_EQ(std::vector<std::string>({"s", "q"}), shorts);
+ std::tie(shorts, longs, pname) = CLI::detail::get_names({"--long", "", "-s", "-q", "", "--also-long"});
+ CHECK(longs == std::vector<std::string>({"long", "also-long"}));
+ CHECK(shorts == std::vector<std::string>({"s", "q"}));
- EXPECT_THROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"-"}), CLI::BadNameString);
- EXPECT_THROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"--"}), CLI::BadNameString);
- EXPECT_THROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"-hi"}), CLI::BadNameString);
- EXPECT_THROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"---hi"}), CLI::BadNameString);
- EXPECT_THROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"one", "two"}), CLI::BadNameString);
+ CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"-"}); }(), CLI::BadNameString);
+ CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"--"}); }(), CLI::BadNameString);
+ CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"-hi"}); }(), CLI::BadNameString);
+ CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"---hi"}); }(),
+ CLI::BadNameString);
+ CHECK_THROWS_AS(
+ [&]() {
+ std::tie(shorts, longs, pname) = CLI::detail::get_names({"one", "two"});
+ }(),
+ CLI::BadNameString);
}
-TEST(String, ToLower) { EXPECT_EQ("one and two", CLI::detail::to_lower("one And TWO")); }
+TEST_CASE("String: ToLower", "[helpers]") { CHECK("one and two" == CLI::detail::to_lower("one And TWO")); }
-TEST(Join, Forward) {
+TEST_CASE("Join: Forward", "[helpers]") {
std::vector<std::string> val{{"one", "two", "three"}};
- EXPECT_EQ("one,two,three", CLI::detail::join(val));
- EXPECT_EQ("one;two;three", CLI::detail::join(val, ";"));
+ CHECK(CLI::detail::join(val) == "one,two,three");
+ CHECK(CLI::detail::join(val, ";") == "one;two;three");
}
-TEST(Join, Backward) {
+TEST_CASE("Join: Backward", "[helpers]") {
std::vector<std::string> val{{"three", "two", "one"}};
- EXPECT_EQ("one,two,three", CLI::detail::rjoin(val));
- EXPECT_EQ("one;two;three", CLI::detail::rjoin(val, ";"));
+ CHECK(CLI::detail::rjoin(val) == "one,two,three");
+ CHECK(CLI::detail::rjoin(val, ";") == "one;two;three");
}
-TEST(SplitUp, Simple) {
+TEST_CASE("SplitUp: Simple", "[helpers]") {
std::vector<std::string> oput = {"one", "two three"};
std::string orig{R"(one "two three")"};
std::vector<std::string> result = CLI::detail::split_up(orig);
- EXPECT_EQ(oput, result);
+ CHECK(result == oput);
}
-TEST(SplitUp, SimpleDifferentQuotes) {
+TEST_CASE("SplitUp: SimpleDifferentQuotes", "[helpers]") {
std::vector<std::string> oput = {"one", "two three"};
std::string orig{R"(one `two three`)"};
std::vector<std::string> result = CLI::detail::split_up(orig);
- EXPECT_EQ(oput, result);
+ CHECK(result == oput);
}
-TEST(SplitUp, SimpleDifferentQuotes2) {
+TEST_CASE("SplitUp: SimpleDifferentQuotes2", "[helpers]") {
std::vector<std::string> oput = {"one", "two three"};
std::string orig{R"(one 'two three')"};
std::vector<std::string> result = CLI::detail::split_up(orig);
- EXPECT_EQ(oput, result);
+ CHECK(result == oput);
}
-TEST(SplitUp, Layered) {
+TEST_CASE("SplitUp: Layered", "[helpers]") {
std::vector<std::string> output = {R"(one 'two three')"};
std::string orig{R"("one 'two three'")"};
std::vector<std::string> result = CLI::detail::split_up(orig);
- EXPECT_EQ(output, result);
+ CHECK(result == output);
}
-TEST(SplitUp, Spaces) {
+TEST_CASE("SplitUp: Spaces", "[helpers]") {
std::vector<std::string> oput = {"one", " two three"};
std::string orig{R"( one " two three" )"};
std::vector<std::string> result = CLI::detail::split_up(orig);
- EXPECT_EQ(oput, result);
+ CHECK(result == oput);
}
-TEST(SplitUp, BadStrings) {
+TEST_CASE("SplitUp: BadStrings", "[helpers]") {
std::vector<std::string> oput = {"one", " two three"};
std::string orig{R"( one " two three )"};
std::vector<std::string> result = CLI::detail::split_up(orig);
- EXPECT_EQ(oput, result);
+ CHECK(result == oput);
oput = {"one", " two three"};
orig = R"( one ' two three )";
result = CLI::detail::split_up(orig);
- EXPECT_EQ(oput, result);
+ CHECK(result == oput);
}
-TEST(Types, TypeName) {
+TEST_CASE("Types: TypeName", "[helpers]") {
std::string int_name = CLI::detail::type_name<int>();
- EXPECT_EQ("INT", int_name);
+ CHECK(int_name == "INT");
std::string int2_name = CLI::detail::type_name<std::int16_t>();
- EXPECT_EQ("INT", int2_name);
+ CHECK(int2_name == "INT");
std::string uint_name = CLI::detail::type_name<unsigned char>();
- EXPECT_EQ("UINT", uint_name);
+ CHECK(uint_name == "UINT");
std::string float_name = CLI::detail::type_name<double>();
- EXPECT_EQ("FLOAT", float_name);
+ CHECK(float_name == "FLOAT");
std::string char_name = CLI::detail::type_name<char>();
- EXPECT_EQ("CHAR", char_name);
+ CHECK(char_name == "CHAR");
std::string vector_name = CLI::detail::type_name<std::vector<int>>();
- EXPECT_EQ("INT", vector_name);
+ CHECK(vector_name == "INT");
vector_name = CLI::detail::type_name<std::vector<double>>();
- EXPECT_EQ("FLOAT", vector_name);
+ CHECK(vector_name == "FLOAT");
static_assert(CLI::detail::classify_object<std::pair<int, std::string>>::value ==
CLI::detail::object_category::tuple_value,
@@ -930,228 +934,228 @@ TEST(Types, TypeName) {
"tuple<string,double> does not read like a tuple");
std::string pair_name = CLI::detail::type_name<std::vector<std::pair<int, std::string>>>();
- EXPECT_EQ("[INT,TEXT]", pair_name);
+ CHECK(pair_name == "[INT,TEXT]");
vector_name = CLI::detail::type_name<std::vector<std::vector<unsigned char>>>();
- EXPECT_EQ("UINT", vector_name);
+ CHECK(vector_name == "UINT");
auto vclass = CLI::detail::classify_object<std::vector<std::vector<unsigned char>>>::value;
- EXPECT_EQ(vclass, CLI::detail::object_category::container_value);
+ CHECK(CLI::detail::object_category::container_value == vclass);
auto tclass = CLI::detail::classify_object<std::tuple<double>>::value;
- EXPECT_EQ(tclass, CLI::detail::object_category::number_constructible);
+ CHECK(CLI::detail::object_category::number_constructible == tclass);
std::string tuple_name = CLI::detail::type_name<std::tuple<double>>();
- EXPECT_EQ("FLOAT", tuple_name);
+ CHECK(tuple_name == "FLOAT");
static_assert(CLI::detail::classify_object<std::tuple<int, std::string>>::value ==
CLI::detail::object_category::tuple_value,
"tuple<int,string> does not read like a tuple");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string>>();
- EXPECT_EQ("[INT,TEXT]", tuple_name);
+ CHECK(tuple_name == "[INT,TEXT]");
tuple_name = CLI::detail::type_name<std::tuple<const int, std::string>>();
- EXPECT_EQ("[INT,TEXT]", tuple_name);
+ CHECK(tuple_name == "[INT,TEXT]");
tuple_name = CLI::detail::type_name<const std::tuple<int, std::string>>();
- EXPECT_EQ("[INT,TEXT]", tuple_name);
+ CHECK(tuple_name == "[INT,TEXT]");
tuple_name = CLI::detail::type_name<std::tuple<std::string, double>>();
- EXPECT_EQ("[TEXT,FLOAT]", tuple_name);
+ CHECK(tuple_name == "[TEXT,FLOAT]");
tuple_name = CLI::detail::type_name<const std::tuple<std::string, double>>();
- EXPECT_EQ("[TEXT,FLOAT]", tuple_name);
+ CHECK(tuple_name == "[TEXT,FLOAT]");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double>>();
- EXPECT_EQ("[INT,TEXT,FLOAT]", tuple_name);
+ CHECK(tuple_name == "[INT,TEXT,FLOAT]");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double, unsigned int>>();
- EXPECT_EQ("[INT,TEXT,FLOAT,UINT]", tuple_name);
+ CHECK(tuple_name == "[INT,TEXT,FLOAT,UINT]");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double, unsigned int, std::string>>();
- EXPECT_EQ("[INT,TEXT,FLOAT,UINT,TEXT]", tuple_name);
+ CHECK(tuple_name == "[INT,TEXT,FLOAT,UINT,TEXT]");
tuple_name = CLI::detail::type_name<std::array<int, 10>>();
- EXPECT_EQ("[INT,INT,INT,INT,INT,INT,INT,INT,INT,INT]", tuple_name);
+ CHECK(tuple_name == "[INT,INT,INT,INT,INT,INT,INT,INT,INT,INT]");
std::string text_name = CLI::detail::type_name<std::string>();
- EXPECT_EQ("TEXT", text_name);
+ CHECK(text_name == "TEXT");
std::string text2_name = CLI::detail::type_name<char *>();
- EXPECT_EQ("TEXT", text2_name);
+ CHECK(text2_name == "TEXT");
enum class test { test1, test2, test3 };
std::string enum_name = CLI::detail::type_name<test>();
- EXPECT_EQ("ENUM", enum_name);
+ CHECK(enum_name == "ENUM");
vclass = CLI::detail::classify_object<std::tuple<test>>::value;
- EXPECT_EQ(vclass, CLI::detail::object_category::tuple_value);
+ CHECK(CLI::detail::object_category::tuple_value == vclass);
static_assert(CLI::detail::classify_object<std::tuple<test>>::value == CLI::detail::object_category::tuple_value,
"tuple<test> does not classify as a tuple");
std::string enum_name2 = CLI::detail::type_name<std::tuple<test>>();
- EXPECT_EQ("ENUM", enum_name2);
+ CHECK(enum_name2 == "ENUM");
std::string umapName = CLI::detail::type_name<std::unordered_map<int, std::tuple<std::string, double>>>();
- EXPECT_EQ("[INT,[TEXT,FLOAT]]", umapName);
+ CHECK(umapName == "[INT,[TEXT,FLOAT]]");
vclass = CLI::detail::classify_object<std::atomic<int>>::value;
}
-TEST(Types, OverflowSmall) {
+TEST_CASE("Types: OverflowSmall", "[helpers]") {
signed char x;
- auto strmax = std::to_string(SCHAR_MAX + 1);
- EXPECT_FALSE(CLI::detail::lexical_cast(strmax, x));
+ auto strmax = std::to_string(std::numeric_limits<signed char>::max() + 1);
+ CHECK_FALSE(CLI::detail::lexical_cast(strmax, x));
unsigned char y;
- strmax = std::to_string(UINT8_MAX + 1);
- EXPECT_FALSE(CLI::detail::lexical_cast(strmax, y));
+ strmax = std::to_string(std::numeric_limits<unsigned char>::max() + 1);
+ CHECK_FALSE(CLI::detail::lexical_cast(strmax, y));
}
-TEST(Types, LexicalCastInt) {
+TEST_CASE("Types: LexicalCastInt", "[helpers]") {
std::string signed_input = "-912";
int x_signed;
- EXPECT_TRUE(CLI::detail::lexical_cast(signed_input, x_signed));
- EXPECT_EQ(-912, x_signed);
+ CHECK(CLI::detail::lexical_cast(signed_input, x_signed));
+ CHECK(x_signed == -912);
std::string unsigned_input = "912";
unsigned int x_unsigned;
- EXPECT_TRUE(CLI::detail::lexical_cast(unsigned_input, x_unsigned));
- EXPECT_EQ((unsigned int)912, x_unsigned);
+ CHECK(CLI::detail::lexical_cast(unsigned_input, x_unsigned));
+ CHECK(x_unsigned == (unsigned int)912);
- EXPECT_FALSE(CLI::detail::lexical_cast(signed_input, x_unsigned));
+ CHECK_FALSE(CLI::detail::lexical_cast(signed_input, x_unsigned));
unsigned char y;
- std::string overflow_input = std::to_string(UINT64_MAX) + "0";
- EXPECT_FALSE(CLI::detail::lexical_cast(overflow_input, y));
+ std::string overflow_input = std::to_string(std::numeric_limits<uint64_t>::max()) + "0";
+ CHECK_FALSE(CLI::detail::lexical_cast(overflow_input, y));
char y_signed;
- EXPECT_FALSE(CLI::detail::lexical_cast(overflow_input, y_signed));
+ CHECK_FALSE(CLI::detail::lexical_cast(overflow_input, y_signed));
std::string bad_input = "hello";
- EXPECT_FALSE(CLI::detail::lexical_cast(bad_input, y));
+ CHECK_FALSE(CLI::detail::lexical_cast(bad_input, y));
std::string extra_input = "912i";
- EXPECT_FALSE(CLI::detail::lexical_cast(extra_input, y));
+ CHECK_FALSE(CLI::detail::lexical_cast(extra_input, y));
std::string empty_input{};
- EXPECT_FALSE(CLI::detail::lexical_cast(empty_input, x_signed));
- EXPECT_FALSE(CLI::detail::lexical_cast(empty_input, x_unsigned));
- EXPECT_FALSE(CLI::detail::lexical_cast(empty_input, y_signed));
+ CHECK_FALSE(CLI::detail::lexical_cast(empty_input, x_signed));
+ CHECK_FALSE(CLI::detail::lexical_cast(empty_input, x_unsigned));
+ CHECK_FALSE(CLI::detail::lexical_cast(empty_input, y_signed));
}
-TEST(Types, LexicalCastDouble) {
+TEST_CASE("Types: LexicalCastDouble", "[helpers]") {
std::string input = "9.12";
long double x;
- EXPECT_TRUE(CLI::detail::lexical_cast(input, x));
- EXPECT_FLOAT_EQ((float)9.12, (float)x);
+ CHECK(CLI::detail::lexical_cast(input, x));
+ CHECK((float)x == Approx((float)9.12));
std::string bad_input = "hello";
- EXPECT_FALSE(CLI::detail::lexical_cast(bad_input, x));
+ CHECK_FALSE(CLI::detail::lexical_cast(bad_input, x));
- std::string overflow_input = "1" + std::to_string(LDBL_MAX);
- EXPECT_TRUE(CLI::detail::lexical_cast(overflow_input, x));
- EXPECT_FALSE(std::isfinite(x));
+ std::string overflow_input = "1" + std::to_string(std::numeric_limits<long double>::max());
+ CHECK(CLI::detail::lexical_cast(overflow_input, x));
+ CHECK_FALSE(std::isfinite(x));
std::string extra_input = "9.12i";
- EXPECT_FALSE(CLI::detail::lexical_cast(extra_input, x));
+ CHECK_FALSE(CLI::detail::lexical_cast(extra_input, x));
std::string empty_input{};
- EXPECT_FALSE(CLI::detail::lexical_cast(empty_input, x));
+ CHECK_FALSE(CLI::detail::lexical_cast(empty_input, x));
}
-TEST(Types, LexicalCastBool) {
+TEST_CASE("Types: LexicalCastBool", "[helpers]") {
std::string input = "false";
bool x;
- EXPECT_TRUE(CLI::detail::lexical_cast(input, x));
- EXPECT_FALSE(x);
+ CHECK(CLI::detail::lexical_cast(input, x));
+ CHECK_FALSE(x);
std::string bad_input = "happy";
- EXPECT_FALSE(CLI::detail::lexical_cast(bad_input, x));
+ CHECK_FALSE(CLI::detail::lexical_cast(bad_input, x));
std::string input_true = "EnaBLE";
- EXPECT_TRUE(CLI::detail::lexical_cast(input_true, x));
- EXPECT_TRUE(x);
+ CHECK(CLI::detail::lexical_cast(input_true, x));
+ CHECK(x);
}
-TEST(Types, LexicalCastString) {
+TEST_CASE("Types: LexicalCastString", "[helpers]") {
std::string input = "one";
std::string output;
CLI::detail::lexical_cast(input, output);
- EXPECT_EQ(input, output);
+ CHECK(output == input);
}
-TEST(Types, LexicalCastParsable) {
+TEST_CASE("Types: LexicalCastParsable", "[helpers]") {
std::string input = "(4.2,7.3)";
std::string fail_input = "4.2,7.3";
std::string extra_input = "(4.2,7.3)e";
std::complex<double> output;
- EXPECT_TRUE(CLI::detail::lexical_cast(input, output));
- EXPECT_DOUBLE_EQ(output.real(), 4.2); // Doing this in one go sometimes has trouble
- EXPECT_DOUBLE_EQ(output.imag(), 7.3); // on clang + gcc 4.8 due to missing const
+ CHECK(CLI::detail::lexical_cast(input, output));
+ CHECK(4.2 == Approx(output.real()));
+ CHECK(7.3 == Approx(output.imag()));
- EXPECT_TRUE(CLI::detail::lexical_cast("2.456", output));
- EXPECT_DOUBLE_EQ(output.real(), 2.456); // Doing this in one go sometimes has trouble
- EXPECT_DOUBLE_EQ(output.imag(), 0.0); // on clang + gcc 4.8 due to missing const
+ CHECK(CLI::detail::lexical_cast("2.456", output));
+ CHECK(2.456 == Approx(output.real()));
+ CHECK(0.0 == Approx(output.imag()));
- EXPECT_FALSE(CLI::detail::lexical_cast(fail_input, output));
- EXPECT_FALSE(CLI::detail::lexical_cast(extra_input, output));
+ CHECK_FALSE(CLI::detail::lexical_cast(fail_input, output));
+ CHECK_FALSE(CLI::detail::lexical_cast(extra_input, output));
}
-TEST(Types, LexicalCastEnum) {
+TEST_CASE("Types: LexicalCastEnum", "[helpers]") {
enum t1 : signed char { v1 = 5, v3 = 7, v5 = -9 };
t1 output;
- EXPECT_TRUE(CLI::detail::lexical_cast("-9", output));
- EXPECT_EQ(output, v5);
+ CHECK(CLI::detail::lexical_cast("-9", output));
+ CHECK(v5 == output);
- EXPECT_FALSE(CLI::detail::lexical_cast("invalid", output));
+ CHECK_FALSE(CLI::detail::lexical_cast("invalid", output));
enum class t2 : std::uint64_t { enum1 = 65, enum2 = 45667, enum3 = 9999999999999 };
t2 output2{t2::enum2};
- EXPECT_TRUE(CLI::detail::lexical_cast("65", output2));
- EXPECT_EQ(output2, t2::enum1);
+ CHECK(CLI::detail::lexical_cast("65", output2));
+ CHECK(t2::enum1 == output2);
- EXPECT_FALSE(CLI::detail::lexical_cast("invalid", output2));
+ CHECK_FALSE(CLI::detail::lexical_cast("invalid", output2));
- EXPECT_TRUE(CLI::detail::lexical_cast("9999999999999", output2));
- EXPECT_EQ(output2, t2::enum3);
+ CHECK(CLI::detail::lexical_cast("9999999999999", output2));
+ CHECK(t2::enum3 == output2);
}
-TEST(Types, LexicalConversionDouble) {
+TEST_CASE("Types: LexicalConversionDouble", "[helpers]") {
CLI::results_t input = {"9.12"};
long double x{0.0};
bool res = CLI::detail::lexical_conversion<long double, double>(input, x);
- EXPECT_TRUE(res);
- EXPECT_FLOAT_EQ((float)9.12, (float)x);
+ CHECK(res);
+ CHECK((float)x == Approx((float)9.12));
CLI::results_t bad_input = {"hello"};
res = CLI::detail::lexical_conversion<long double, double>(input, x);
- EXPECT_TRUE(res);
+ CHECK(res);
}
-TEST(Types, LexicalConversionDoubleTuple) {
+TEST_CASE("Types: LexicalConversionDoubleTuple", "[helpers]") {
CLI::results_t input = {"9.12"};
std::tuple<double> x{0.0};
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
- EXPECT_DOUBLE_EQ(9.12, std::get<0>(x));
+ CHECK(res);
+ CHECK(std::get<0>(x) == Approx(9.12));
CLI::results_t bad_input = {"hello"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
+ CHECK(res);
}
-TEST(Types, LexicalConversionVectorDouble) {
+TEST_CASE("Types: LexicalConversionVectorDouble", "[helpers]") {
CLI::results_t input = {"9.12", "10.79", "-3.54"};
std::vector<double> x;
bool res = CLI::detail::lexical_conversion<std::vector<double>, double>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(x.size(), 3u);
- EXPECT_DOUBLE_EQ(x[2], -3.54);
+ CHECK(res);
+ CHECK(3u == x.size());
+ CHECK(-3.54 == Approx(x[2]));
res = CLI::detail::lexical_conversion<std::vector<double>, std::vector<double>>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(x.size(), 3u);
- EXPECT_DOUBLE_EQ(x[2], -3.54);
+ CHECK(res);
+ CHECK(3u == x.size());
+ CHECK(-3.54 == Approx(x[2]));
}
static_assert(!CLI::detail::is_tuple_like<std::vector<double>>::value, "vector should not be like a tuple");
@@ -1162,107 +1166,107 @@ static_assert(!CLI::detail::is_tuple_like<std::string>::value, "std::string shou
static_assert(!CLI::detail::is_tuple_like<double>::value, "double should not be like a tuple");
static_assert(CLI::detail::is_tuple_like<std::tuple<double, int, double>>::value, "tuple should look like a tuple");
-TEST(Types, LexicalConversionTuple2) {
+TEST_CASE("Types: LexicalConversionTuple2", "[helpers]") {
CLI::results_t input = {"9.12", "19"};
std::tuple<double, int> x{0.0, 0};
static_assert(CLI::detail::is_tuple_like<decltype(x)>::value,
"tuple type must have is_tuple_like trait to be true");
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(std::get<1>(x), 19);
- EXPECT_DOUBLE_EQ(std::get<0>(x), 9.12);
+ CHECK(res);
+ CHECK(19 == std::get<1>(x));
+ CHECK(9.12 == Approx(std::get<0>(x)));
input = {"19", "9.12"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_FALSE(res);
+ CHECK_FALSE(res);
}
-TEST(Types, LexicalConversionTuple3) {
+TEST_CASE("Types: LexicalConversionTuple3", "[helpers]") {
CLI::results_t input = {"9.12", "19", "hippo"};
std::tuple<double, int, std::string> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(std::get<1>(x), 19);
- EXPECT_DOUBLE_EQ(std::get<0>(x), 9.12);
- EXPECT_EQ(std::get<2>(x), "hippo");
+ CHECK(res);
+ CHECK(19 == std::get<1>(x));
+ CHECK(9.12 == Approx(std::get<0>(x)));
+ CHECK("hippo" == std::get<2>(x));
input = {"19", "9.12"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_FALSE(res);
+ CHECK_FALSE(res);
}
-TEST(Types, LexicalConversionTuple4) {
+TEST_CASE("Types: LexicalConversionTuple4", "[helpers]") {
CLI::results_t input = {"9.12", "19", "18.6", "5.87"};
std::array<double, 4> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
- EXPECT_DOUBLE_EQ(std::get<1>(x), 19);
- EXPECT_DOUBLE_EQ(x[0], 9.12);
- EXPECT_DOUBLE_EQ(x[2], 18.6);
- EXPECT_DOUBLE_EQ(x[3], 5.87);
+ CHECK(res);
+ CHECK(19 == Approx(std::get<1>(x)));
+ CHECK(9.12 == Approx(x[0]));
+ CHECK(18.6 == Approx(x[2]));
+ CHECK(5.87 == Approx(x[3]));
input = {"19", "9.12", "hippo"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_FALSE(res);
+ CHECK_FALSE(res);
}
-TEST(Types, LexicalConversionTuple5) {
+TEST_CASE("Types: LexicalConversionTuple5", "[helpers]") {
CLI::results_t input = {"9", "19", "18", "5", "235235"};
std::array<unsigned int, 5> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(std::get<1>(x), 19u);
- EXPECT_EQ(x[0], 9u);
- EXPECT_EQ(x[2], 18u);
- EXPECT_EQ(x[3], 5u);
- EXPECT_EQ(x[4], 235235u);
+ CHECK(res);
+ CHECK(19u == std::get<1>(x));
+ CHECK(9u == x[0]);
+ CHECK(18u == x[2]);
+ CHECK(5u == x[3]);
+ CHECK(235235u == x[4]);
input = {"19", "9.12", "hippo"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_FALSE(res);
+ CHECK_FALSE(res);
}
-TEST(Types, LexicalConversionTuple10) {
+TEST_CASE("Types: LexicalConversionTuple10", "[helpers]") {
CLI::results_t input = {"9", "19", "18", "5", "235235", "9", "19", "18", "5", "235235"};
std::array<unsigned int, 10> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(std::get<1>(x), 19u);
- EXPECT_EQ(x[0], 9u);
- EXPECT_EQ(x[2], 18u);
- EXPECT_EQ(x[3], 5u);
- EXPECT_EQ(x[4], 235235u);
- EXPECT_EQ(x[9], 235235u);
+ CHECK(res);
+ CHECK(19u == std::get<1>(x));
+ CHECK(9u == x[0]);
+ CHECK(18u == x[2]);
+ CHECK(5u == x[3]);
+ CHECK(235235u == x[4]);
+ CHECK(235235u == x[9]);
input[3] = "hippo";
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
- EXPECT_FALSE(res);
+ CHECK_FALSE(res);
}
-TEST(Types, LexicalConversionTuple10XC) {
+TEST_CASE("Types: LexicalConversionTuple10XC", "[helpers]") {
CLI::results_t input = {"9", "19", "18", "5", "235235", "9", "19", "18", "5", "235235"};
std::array<double, 10> x;
bool res = CLI::detail::lexical_conversion<decltype(x), std::array<unsigned int, 10>>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(std::get<1>(x), 19.0);
- EXPECT_EQ(x[0], 9.0);
- EXPECT_EQ(x[2], 18.0);
- EXPECT_EQ(x[3], 5.0);
- EXPECT_EQ(x[4], 235235.0);
- EXPECT_EQ(x[9], 235235.0);
+ CHECK(res);
+ CHECK(19.0 == std::get<1>(x));
+ CHECK(9.0 == x[0]);
+ CHECK(18.0 == x[2]);
+ CHECK(5.0 == x[3]);
+ CHECK(235235.0 == x[4]);
+ CHECK(235235.0 == x[9]);
input[3] = "19.7";
res = CLI::detail::lexical_conversion<decltype(x), std::array<unsigned int, 10>>(input, x);
- EXPECT_FALSE(res);
+ CHECK_FALSE(res);
}
-TEST(Types, LexicalConversionComplex) {
+TEST_CASE("Types: LexicalConversionComplex", "[helpers]") {
CLI::results_t input = {"5.1", "3.5"};
std::complex<double> x;
bool res = CLI::detail::lexical_conversion<std::complex<double>, std::array<double, 2>>(input, x);
- EXPECT_TRUE(res);
- EXPECT_EQ(x.real(), 5.1);
- EXPECT_EQ(x.imag(), 3.5);
+ CHECK(res);
+ CHECK(5.1 == x.real());
+ CHECK(3.5 == x.imag());
}
static_assert(CLI::detail::is_wrapper<std::vector<double>>::value, "vector double should be a wrapper");
@@ -1285,16 +1289,16 @@ static_assert(CLI::detail::is_readable_container<const std::vector<int>>::value,
static_assert(CLI::detail::is_readable_container<const std::vector<int> &>::value,
"const vector int & should be a readable container");
-TEST(FixNewLines, BasicCheck) {
+TEST_CASE("FixNewLines: BasicCheck", "[helpers]") {
std::string input = "one\ntwo";
std::string output = "one\n; two";
std::string result = CLI::detail::fix_newlines("; ", input);
- EXPECT_EQ(result, output);
+ CHECK(output == result);
}
-TEST(FixNewLines, EdgesCheck) {
+TEST_CASE("FixNewLines: EdgesCheck", "[helpers]") {
std::string input = "\none\ntwo\n";
std::string output = "\n; one\n; two\n; ";
std::string result = CLI::detail::fix_newlines("; ", input);
- EXPECT_EQ(result, output);
+ CHECK(output == result);
}
diff --git a/packages/CLI11/tests/NewParseTest.cpp b/packages/CLI11/tests/NewParseTest.cpp
index cf0adc384726c3b51fbdcfb0244ff105914701c0..d9d9dbf91ca777d8c70fa2f289316e535acec0f0 100644
--- a/packages/CLI11/tests/NewParseTest.cpp
+++ b/packages/CLI11/tests/NewParseTest.cpp
@@ -5,159 +5,159 @@
// SPDX-License-Identifier: BSD-3-Clause
#include "app_helper.hpp"
-#include "gmock/gmock.h"
+
#include <complex>
#include <cstdint>
-using ::testing::HasSubstr;
+using Catch::Matchers::Contains;
using cx = std::complex<double>;
-TEST_F(TApp, Complex) {
+TEST_CASE_METHOD(TApp, "Complex", "[newparse]") {
cx comp{1, 2};
app.add_complex("-c,--complex", comp, "", true);
args = {"-c", "4", "3"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
- EXPECT_THAT(help, HasSubstr("COMPLEX"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
+ CHECK_THAT(help, Contains("COMPLEX"));
- EXPECT_DOUBLE_EQ(1, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
-TEST_F(TApp, ComplexOption) {
+TEST_CASE_METHOD(TApp, "ComplexOption", "[newparse]") {
cx comp{1, 2};
app.add_option("-c,--complex", comp, "", true);
args = {"-c", "4", "3"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
- EXPECT_THAT(help, HasSubstr("COMPLEX"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
+ CHECK_THAT(help, Contains("COMPLEX"));
- EXPECT_DOUBLE_EQ(1, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
-TEST_F(TApp, ComplexFloat) {
+TEST_CASE_METHOD(TApp, "ComplexFloat", "[newparse]") {
std::complex<float> comp{1, 2};
app.add_complex<std::complex<float>, float>("-c,--complex", comp, "", true);
args = {"-c", "4", "3"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
- EXPECT_THAT(help, HasSubstr("COMPLEX"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
+ CHECK_THAT(help, Contains("COMPLEX"));
- EXPECT_FLOAT_EQ(1, comp.real());
- EXPECT_FLOAT_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_FLOAT_EQ(4, comp.real());
- EXPECT_FLOAT_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
-TEST_F(TApp, ComplexFloatOption) {
+TEST_CASE_METHOD(TApp, "ComplexFloatOption", "[newparse]") {
std::complex<float> comp{1, 2};
app.add_option("-c,--complex", comp, "", true);
args = {"-c", "4", "3"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
- EXPECT_THAT(help, HasSubstr("COMPLEX"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
+ CHECK_THAT(help, Contains("COMPLEX"));
- EXPECT_FLOAT_EQ(1, comp.real());
- EXPECT_FLOAT_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_FLOAT_EQ(4, comp.real());
- EXPECT_FLOAT_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
-TEST_F(TApp, ComplexWithDelimiter) {
+TEST_CASE_METHOD(TApp, "ComplexWithDelimiter", "[newparse]") {
cx comp{1, 2};
app.add_complex("-c,--complex", comp, "", true)->delimiter('+');
args = {"-c", "4+3i"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
- EXPECT_THAT(help, HasSubstr("COMPLEX"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
+ CHECK_THAT(help, Contains("COMPLEX"));
- EXPECT_DOUBLE_EQ(1, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
args = {"-c", "5+-3i"};
run();
- EXPECT_DOUBLE_EQ(5, comp.real());
- EXPECT_DOUBLE_EQ(-3, comp.imag());
+ CHECK(comp.real() == Approx(5));
+ CHECK(comp.imag() == Approx(-3));
args = {"-c", "6", "-4i"};
run();
- EXPECT_DOUBLE_EQ(6, comp.real());
- EXPECT_DOUBLE_EQ(-4, comp.imag());
+ CHECK(comp.real() == Approx(6));
+ CHECK(comp.imag() == Approx(-4));
}
-TEST_F(TApp, ComplexWithDelimiterOption) {
+TEST_CASE_METHOD(TApp, "ComplexWithDelimiterOption", "[newparse]") {
cx comp{1, 2};
app.add_option("-c,--complex", comp, "", true)->delimiter('+');
args = {"-c", "4+3i"};
std::string help = app.help();
- EXPECT_THAT(help, HasSubstr("1"));
- EXPECT_THAT(help, HasSubstr("2"));
- EXPECT_THAT(help, HasSubstr("COMPLEX"));
+ CHECK_THAT(help, Contains("1"));
+ CHECK_THAT(help, Contains("2"));
+ CHECK_THAT(help, Contains("COMPLEX"));
- EXPECT_DOUBLE_EQ(1, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(1));
+ CHECK(comp.imag() == Approx(2));
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
args = {"-c", "5+-3i"};
run();
- EXPECT_DOUBLE_EQ(5, comp.real());
- EXPECT_DOUBLE_EQ(-3, comp.imag());
+ CHECK(comp.real() == Approx(5));
+ CHECK(comp.imag() == Approx(-3));
args = {"-c", "6", "-4i"};
run();
- EXPECT_DOUBLE_EQ(6, comp.real());
- EXPECT_DOUBLE_EQ(-4, comp.imag());
+ CHECK(comp.real() == Approx(6));
+ CHECK(comp.imag() == Approx(-4));
}
-TEST_F(TApp, ComplexIgnoreI) {
+TEST_CASE_METHOD(TApp, "ComplexIgnoreI", "[newparse]") {
cx comp{1, 2};
app.add_complex("-c,--complex", comp);
@@ -165,11 +165,11 @@ TEST_F(TApp, ComplexIgnoreI) {
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
-TEST_F(TApp, ComplexIgnoreIOption) {
+TEST_CASE_METHOD(TApp, "ComplexIgnoreIOption", "[newparse]") {
cx comp{1, 2};
app.add_option("-c,--complex", comp);
@@ -177,122 +177,122 @@ TEST_F(TApp, ComplexIgnoreIOption) {
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(3, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(3));
}
-TEST_F(TApp, ComplexSingleArg) {
+TEST_CASE_METHOD(TApp, "ComplexSingleArg", "[newparse]") {
cx comp{1, 2};
app.add_complex("-c,--complex", comp);
args = {"-c", "4"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(0, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(0));
args = {"-c", "4-2i"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(-2, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(-2));
args = {"-c", "4+2i"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(2));
args = {"-c", "-4+2j"};
run();
- EXPECT_DOUBLE_EQ(-4, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(-4));
+ CHECK(comp.imag() == Approx(2));
args = {"-c", "-4.2-2j"};
run();
- EXPECT_DOUBLE_EQ(-4.2, comp.real());
- EXPECT_DOUBLE_EQ(-2, comp.imag());
+ CHECK(comp.real() == Approx(-4.2));
+ CHECK(comp.imag() == Approx(-2));
args = {"-c", "-4.2-2.7i"};
run();
- EXPECT_DOUBLE_EQ(-4.2, comp.real());
- EXPECT_DOUBLE_EQ(-2.7, comp.imag());
+ CHECK(comp.real() == Approx(-4.2));
+ CHECK(comp.imag() == Approx(-2.7));
}
-TEST_F(TApp, ComplexSingleArgOption) {
+TEST_CASE_METHOD(TApp, "ComplexSingleArgOption", "[newparse]") {
cx comp{1, 2};
app.add_option("-c,--complex", comp);
args = {"-c", "4"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(0, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(0));
args = {"-c", "4-2i"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(-2, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(-2));
args = {"-c", "4+2i"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(2));
args = {"-c", "-4+2j"};
run();
- EXPECT_DOUBLE_EQ(-4, comp.real());
- EXPECT_DOUBLE_EQ(2, comp.imag());
+ CHECK(comp.real() == Approx(-4));
+ CHECK(comp.imag() == Approx(2));
args = {"-c", "-4.2-2j"};
run();
- EXPECT_DOUBLE_EQ(-4.2, comp.real());
- EXPECT_DOUBLE_EQ(-2, comp.imag());
+ CHECK(comp.real() == Approx(-4.2));
+ CHECK(comp.imag() == Approx(-2));
args = {"-c", "-4.2-2.7i"};
run();
- EXPECT_DOUBLE_EQ(-4.2, comp.real());
- EXPECT_DOUBLE_EQ(-2.7, comp.imag());
+ CHECK(comp.real() == Approx(-4.2));
+ CHECK(comp.imag() == Approx(-2.7));
}
-TEST_F(TApp, ComplexSingleImag) {
+TEST_CASE_METHOD(TApp, "ComplexSingleImag", "[newparse]") {
cx comp{1, 2};
app.add_complex("-c,--complex", comp);
args = {"-c", "4j"};
run();
- EXPECT_DOUBLE_EQ(0, comp.real());
- EXPECT_DOUBLE_EQ(4, comp.imag());
+ CHECK(comp.real() == Approx(0));
+ CHECK(comp.imag() == Approx(4));
args = {"-c", "-4j"};
run();
- EXPECT_DOUBLE_EQ(0, comp.real());
- EXPECT_DOUBLE_EQ(-4, comp.imag());
+ CHECK(comp.real() == Approx(0));
+ CHECK(comp.imag() == Approx(-4));
args = {"-c", "-4"};
run();
- EXPECT_DOUBLE_EQ(-4, comp.real());
- EXPECT_DOUBLE_EQ(0, comp.imag());
+ CHECK(comp.real() == Approx(-4));
+ CHECK(comp.imag() == Approx(0));
args = {"-c", "+4"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(0, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(0));
}
-TEST_F(TApp, ComplexSingleImagOption) {
+TEST_CASE_METHOD(TApp, "ComplexSingleImagOption", "[newparse]") {
cx comp{1, 2};
app.add_option("-c,--complex", comp);
args = {"-c", "4j"};
run();
- EXPECT_DOUBLE_EQ(0, comp.real());
- EXPECT_DOUBLE_EQ(4, comp.imag());
+ CHECK(comp.real() == Approx(0));
+ CHECK(comp.imag() == Approx(4));
args = {"-c", "-4j"};
run();
- EXPECT_DOUBLE_EQ(0, comp.real());
- EXPECT_DOUBLE_EQ(-4, comp.imag());
+ CHECK(comp.real() == Approx(0));
+ CHECK(comp.imag() == Approx(-4));
args = {"-c", "-4"};
run();
- EXPECT_DOUBLE_EQ(-4, comp.real());
- EXPECT_DOUBLE_EQ(0, comp.imag());
+ CHECK(comp.real() == Approx(-4));
+ CHECK(comp.imag() == Approx(0));
args = {"-c", "+4"};
run();
- EXPECT_DOUBLE_EQ(4, comp.real());
- EXPECT_DOUBLE_EQ(0, comp.imag());
+ CHECK(comp.real() == Approx(4));
+ CHECK(comp.imag() == Approx(0));
}
/// Simple class containing two strings useful for testing lexical cast and conversions
@@ -321,24 +321,24 @@ template <> bool lexical_cast<spair>(const std::string &input, spair &output) {
} // namespace detail
} // namespace CLI
-TEST_F(TApp, custom_string_converter) {
+TEST_CASE_METHOD(TApp, "custom_string_converter", "[newparse]") {
spair val;
app.add_option("-d,--dual_string", val);
args = {"-d", "string1:string2"};
run();
- EXPECT_EQ(val.first, "string1");
- EXPECT_EQ(val.second, "string2");
+ CHECK("string1" == val.first);
+ CHECK("string2" == val.second);
}
-TEST_F(TApp, custom_string_converterFail) {
+TEST_CASE_METHOD(TApp, "custom_string_converterFail", "[newparse]") {
spair val;
app.add_option("-d,--dual_string", val);
args = {"-d", "string2"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
/// simple class to wrap another with a very specific type constructor and assignment operators to test out some of the
@@ -369,14 +369,14 @@ static_assert(CLI::detail::is_direct_constructible<objWrapper<std::string>, std:
static_assert(!std::is_assignable<objWrapper<std::string>, std::string>::value,
"string wrapper is improperly assignable");
-TEST_F(TApp, stringWrapper) {
+TEST_CASE_METHOD(TApp, "stringWrapper", "[newparse]") {
objWrapper<std::string> sWrapper;
app.add_option("-v", sWrapper);
args = {"-v", "string test"};
run();
- EXPECT_EQ(sWrapper.value(), "string test");
+ CHECK("string test" == sWrapper.value());
}
static_assert(CLI::detail::is_direct_constructible<objWrapper<double>, double>::value,
@@ -388,18 +388,18 @@ static_assert(!CLI::detail::is_direct_constructible<objWrapper<double>, int>::va
static_assert(!CLI::detail::is_istreamable<objWrapper<double>>::value,
"double wrapper is input streamable and it shouldn't be");
-TEST_F(TApp, doubleWrapper) {
+TEST_CASE_METHOD(TApp, "doubleWrapper", "[newparse]") {
objWrapper<double> dWrapper;
app.add_option("-v", dWrapper);
args = {"-v", "2.36"};
run();
- EXPECT_EQ(dWrapper.value(), 2.36);
+ CHECK(2.36 == dWrapper.value());
args = {"-v", "thing"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
static_assert(CLI::detail::is_direct_constructible<objWrapper<int>, int>::value,
@@ -411,17 +411,17 @@ static_assert(!CLI::detail::is_direct_constructible<objWrapper<int>, double>::va
static_assert(!CLI::detail::is_istreamable<objWrapper<int>>::value,
"int wrapper is input streamable and it shouldn't be");
-TEST_F(TApp, intWrapper) {
+TEST_CASE_METHOD(TApp, "intWrapper", "[newparse]") {
objWrapper<int> iWrapper;
app.add_option("-v", iWrapper);
args = {"-v", "45"};
run();
- EXPECT_EQ(iWrapper.value(), 45);
+ CHECK(45 == iWrapper.value());
args = {"-v", "thing"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
static_assert(!CLI::detail::is_direct_constructible<objWrapper<float>, int>::value,
@@ -432,17 +432,17 @@ static_assert(!CLI::detail::is_direct_constructible<objWrapper<float>, double>::
static_assert(!CLI::detail::is_istreamable<objWrapper<float>>::value,
"float wrapper is input streamable and it shouldn't be");
-TEST_F(TApp, floatWrapper) {
+TEST_CASE_METHOD(TApp, "floatWrapper", "[newparse]") {
objWrapper<float> iWrapper;
app.add_option<objWrapper<float>, float>("-v", iWrapper);
args = {"-v", "45.3"};
run();
- EXPECT_EQ(iWrapper.value(), 45.3f);
+ CHECK(45.3f == iWrapper.value());
args = {"-v", "thing"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
#endif
@@ -461,26 +461,26 @@ class dobjWrapper {
int ival_{0};
};
-TEST_F(TApp, dobjWrapper) {
+TEST_CASE_METHOD(TApp, "dobjWrapper", "[newparse]") {
dobjWrapper iWrapper;
app.add_option("-v", iWrapper);
args = {"-v", "45"};
run();
- EXPECT_EQ(iWrapper.ivalue(), 45);
- EXPECT_EQ(iWrapper.dvalue(), 0.0);
+ CHECK(45 == iWrapper.ivalue());
+ CHECK(0.0 == iWrapper.dvalue());
args = {"-v", "thing"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
iWrapper = dobjWrapper{};
args = {"-v", "45.1"};
run();
- EXPECT_EQ(iWrapper.ivalue(), 0);
- EXPECT_EQ(iWrapper.dvalue(), 45.1);
+ CHECK(0 == iWrapper.ivalue());
+ CHECK(45.1 == iWrapper.dvalue());
}
/// simple class to wrap another with a very specific type constructor and assignment operators to test out some of the
@@ -507,25 +507,25 @@ template <class X> class AobjWrapper {
static_assert(std::is_assignable<AobjWrapper<std::uint16_t> &, std::uint16_t>::value,
"AobjWrapper not assignable like it should be ");
-TEST_F(TApp, uint16Wrapper) {
+TEST_CASE_METHOD(TApp, "uint16Wrapper", "[newparse]") {
AobjWrapper<std::uint16_t> sWrapper;
app.add_option<AobjWrapper<std::uint16_t>, std::uint16_t>("-v", sWrapper);
args = {"-v", "9"};
run();
- EXPECT_EQ(sWrapper.value(), 9u);
+ CHECK(9u == sWrapper.value());
args = {"-v", "thing"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
args = {"-v", "72456245754"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
args = {"-v", "-3"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
template <class T> class SimpleWrapper {
@@ -539,25 +539,25 @@ template <class T> class SimpleWrapper {
T val_;
};
-TEST_F(TApp, wrapperInt) {
+TEST_CASE_METHOD(TApp, "wrapperInt", "[newparse]") {
SimpleWrapper<int> wrap;
app.add_option("--val", wrap);
args = {"--val", "2"};
run();
- EXPECT_EQ(wrap.getRef(), 2);
+ CHECK(2 == wrap.getRef());
}
-TEST_F(TApp, wrapperString) {
+TEST_CASE_METHOD(TApp, "wrapperString", "[newparse]") {
SimpleWrapper<std::string> wrap;
app.add_option("--val", wrap);
args = {"--val", "str"};
run();
- EXPECT_EQ(wrap.getRef(), "str");
+ CHECK("str" == wrap.getRef());
}
-TEST_F(TApp, wrapperVector) {
+TEST_CASE_METHOD(TApp, "wrapperVector", "[newparse]") {
SimpleWrapper<std::vector<int>> wrap;
app.add_option("--val", wrap);
args = {"--val", "1", "2", "3", "4"};
@@ -565,10 +565,10 @@ TEST_F(TApp, wrapperVector) {
run();
auto v1 = wrap.getRef();
auto v2 = std::vector<int>{1, 2, 3, 4};
- EXPECT_EQ(v1, v2);
+ CHECK(v2 == v1);
}
-TEST_F(TApp, wrapperwrapperString) {
+TEST_CASE_METHOD(TApp, "wrapperwrapperString", "[newparse]") {
SimpleWrapper<SimpleWrapper<std::string>> wrap;
app.add_option("--val", wrap);
args = {"--val", "arg"};
@@ -576,10 +576,10 @@ TEST_F(TApp, wrapperwrapperString) {
run();
auto v1 = wrap.getRef().getRef();
auto v2 = "arg";
- EXPECT_EQ(v1, v2);
+ CHECK(v2 == v1);
}
-TEST_F(TApp, wrapperwrapperVector) {
+TEST_CASE_METHOD(TApp, "wrapperwrapperVector", "[newparse]") {
SimpleWrapper<SimpleWrapper<std::vector<int>>> wrap;
auto opt = app.add_option("--val", wrap);
args = {"--val", "1", "2", "3", "4"};
@@ -587,20 +587,20 @@ TEST_F(TApp, wrapperwrapperVector) {
run();
auto v1 = wrap.getRef().getRef();
auto v2 = std::vector<int>{1, 2, 3, 4};
- EXPECT_EQ(v1, v2);
+ CHECK(v2 == v1);
opt->type_size(0, 5);
args = {"--val"};
run();
- EXPECT_TRUE(wrap.getRef().getRef().empty());
+ CHECK(wrap.getRef().getRef().empty());
args = {"--val", "happy", "sad"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, wrapperComplex) {
+TEST_CASE_METHOD(TApp, "wrapperComplex", "[newparse]") {
SimpleWrapper<std::complex<double>> wrap;
app.add_option("--val", wrap);
args = {"--val", "1", "2"};
@@ -608,26 +608,26 @@ TEST_F(TApp, wrapperComplex) {
run();
auto &v1 = wrap.getRef();
auto v2 = std::complex<double>{1, 2};
- EXPECT_EQ(v1.real(), v2.real());
- EXPECT_EQ(v1.imag(), v2.imag());
+ CHECK(v2.real() == v1.real());
+ CHECK(v2.imag() == v1.imag());
args = {"--val", "1.4-4j"};
run();
v2 = std::complex<double>{1.4, -4};
- EXPECT_EQ(v1.real(), v2.real());
- EXPECT_EQ(v1.imag(), v2.imag());
+ CHECK(v2.real() == v1.real());
+ CHECK(v2.imag() == v1.imag());
}
-TEST_F(TApp, vectorComplex) {
+TEST_CASE_METHOD(TApp, "vectorComplex", "[newparse]") {
std::vector<std::complex<double>> vcomplex;
app.add_option("--val", vcomplex);
args = {"--val", "1", "2", "--val", "1.4-4j"};
run();
- ASSERT_EQ(vcomplex.size(), 2U);
- EXPECT_EQ(vcomplex[0].real(), 1.0);
- EXPECT_EQ(vcomplex[0].imag(), 2.0);
- EXPECT_EQ(vcomplex[1].real(), 1.4);
- EXPECT_EQ(vcomplex[1].imag(), -4.0);
+ REQUIRE(2U == vcomplex.size());
+ CHECK(1.0 == vcomplex[0].real());
+ CHECK(2.0 == vcomplex[0].imag());
+ CHECK(1.4 == vcomplex[1].real());
+ CHECK(-4.0 == vcomplex[1].imag());
}
diff --git a/packages/CLI11/tests/OptionGroupTest.cpp b/packages/CLI11/tests/OptionGroupTest.cpp
index e510c1a390847b0494e60f7608a9b6a85ab073bd..175f31dc3daf5de4da456c7a304a235d31aec42e 100644
--- a/packages/CLI11/tests/OptionGroupTest.cpp
+++ b/packages/CLI11/tests/OptionGroupTest.cpp
@@ -6,15 +6,11 @@
#include "app_helper.hpp"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-using ::testing::HasSubstr;
-using ::testing::Not;
+using Catch::Matchers::Contains;
using vs_t = std::vector<std::string>;
-TEST_F(TApp, BasicOptionGroup) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroup", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res;
ogroup->add_option("--test1", res);
@@ -23,11 +19,11 @@ TEST_F(TApp, BasicOptionGroup) {
args = {"--test1", "5"};
run();
- EXPECT_EQ(res, 5);
- EXPECT_EQ(app.count_all(), 1u);
+ CHECK(5 == res);
+ CHECK(1u == app.count_all());
}
-TEST_F(TApp, BasicOptionGroupExact) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupExact", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -38,20 +34,20 @@ TEST_F(TApp, BasicOptionGroupExact) {
ogroup->require_option(1);
args = {"--test1", "5"};
run();
- EXPECT_EQ(res, 5);
+ CHECK(5 == res);
args = {"--test1", "5", "--test2", "4"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
std::string help = ogroup->help();
auto exactloc = help.find("[Exactly 1");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupExactTooMany) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupExactTooMany", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -61,10 +57,10 @@ TEST_F(TApp, BasicOptionGroupExactTooMany) {
app.add_option("--option", val2);
ogroup->require_option(10);
args = {"--test1", "5"};
- EXPECT_THROW(run(), CLI::InvalidError);
+ CHECK_THROWS_AS(run(), CLI::InvalidError);
}
-TEST_F(TApp, BasicOptionGroupMinMax) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMinMax", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -75,20 +71,20 @@ TEST_F(TApp, BasicOptionGroupMinMax) {
ogroup->require_option(1, 1);
args = {"--test1", "5"};
run();
- EXPECT_EQ(res, 5);
+ CHECK(5 == res);
args = {"--test1", "5", "--test2", "4"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
std::string help = ogroup->help();
auto exactloc = help.find("[Exactly 1");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMinMaxDifferent) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMinMaxDifferent", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -99,24 +95,24 @@ TEST_F(TApp, BasicOptionGroupMinMaxDifferent) {
ogroup->require_option(1, 2);
args = {"--test1", "5"};
run();
- EXPECT_EQ(res, 5);
+ CHECK(5 == res);
args = {"--test1", "5", "--test2", "4"};
- EXPECT_NO_THROW(run());
- EXPECT_EQ(app.count_all(), 2u);
+ CHECK_NOTHROW(run());
+ CHECK(2u == app.count_all());
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
std::string help = ogroup->help();
auto exactloc = help.find("[Between 1 and 2");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMinMaxDifferentReversed) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMinMaxDifferentReversed", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -125,30 +121,30 @@ TEST_F(TApp, BasicOptionGroupMinMaxDifferentReversed) {
int val2{0};
app.add_option("--option", val2);
ogroup->require_option(2, 1);
- EXPECT_EQ(ogroup->get_require_option_min(), 2u);
- EXPECT_EQ(ogroup->get_require_option_max(), 1u);
+ CHECK(2u == ogroup->get_require_option_min());
+ CHECK(1u == ogroup->get_require_option_max());
args = {"--test1", "5"};
- EXPECT_THROW(run(), CLI::InvalidError);
+ CHECK_THROWS_AS(run(), CLI::InvalidError);
ogroup->require_option(1, 2);
- EXPECT_NO_THROW(run());
- EXPECT_EQ(res, 5);
- EXPECT_EQ(ogroup->get_require_option_min(), 1u);
- EXPECT_EQ(ogroup->get_require_option_max(), 2u);
+ CHECK_NOTHROW(run());
+ CHECK(5 == res);
+ CHECK(1u == ogroup->get_require_option_min());
+ CHECK(2u == ogroup->get_require_option_max());
args = {"--test1", "5", "--test2", "4"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
std::string help = ogroup->help();
auto exactloc = help.find("[Between 1 and 2");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMax) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMax", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -159,20 +155,20 @@ TEST_F(TApp, BasicOptionGroupMax) {
ogroup->require_option(-2);
args = {"--test1", "5"};
run();
- EXPECT_EQ(res, 5);
+ CHECK(5 == res);
args = {"--option", "9"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
std::string help = ogroup->help();
auto exactloc = help.find("[At most 2");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMax1) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMax1", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -183,20 +179,20 @@ TEST_F(TApp, BasicOptionGroupMax1) {
ogroup->require_option(-1);
args = {"--test1", "5"};
run();
- EXPECT_EQ(res, 5);
+ CHECK(5 == res);
args = {"--option", "9"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"--test1", "5", "--test2", "4"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
std::string help = ogroup->help();
auto exactloc = help.find("[At most 1");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMin) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMin", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -207,17 +203,17 @@ TEST_F(TApp, BasicOptionGroupMin) {
ogroup->require_option();
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
std::string help = ogroup->help();
auto exactloc = help.find("[At least 1");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupExact2) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupExact2", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -228,20 +224,20 @@ TEST_F(TApp, BasicOptionGroupExact2) {
ogroup->require_option(2);
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test3=5"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
std::string help = ogroup->help();
auto exactloc = help.find("[Exactly 2");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMin2) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMin2", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
int res{0};
ogroup->add_option("--test1", res);
@@ -252,17 +248,17 @@ TEST_F(TApp, BasicOptionGroupMin2) {
ogroup->require_option(2, 0);
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
std::string help = ogroup->help();
auto exactloc = help.find("[At least 2");
- EXPECT_NE(exactloc, std::string::npos);
+ CHECK(std::string::npos != exactloc);
}
-TEST_F(TApp, BasicOptionGroupMinMoved) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMinMoved", "[optiongroup]") {
int res{0};
auto opt1 = app.add_option("--test1", res);
@@ -278,20 +274,20 @@ TEST_F(TApp, BasicOptionGroupMinMoved) {
ogroup->add_option(opt3);
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
std::string help = app.help();
auto exactloc = help.find("[At least 1");
auto oloc = help.find("--test1");
- EXPECT_NE(exactloc, std::string::npos);
- EXPECT_NE(oloc, std::string::npos);
- EXPECT_LT(exactloc, oloc);
+ CHECK(std::string::npos != exactloc);
+ CHECK(std::string::npos != oloc);
+ CHECK(oloc > exactloc);
}
-TEST_F(TApp, BasicOptionGroupMinMovedAsGroup) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupMinMovedAsGroup", "[optiongroup]") {
int res{0};
auto opt1 = app.add_option("--test1", res);
@@ -304,22 +300,22 @@ TEST_F(TApp, BasicOptionGroupMinMovedAsGroup) {
ogroup->require_option();
ogroup->add_options(opt1, opt2, opt3);
- EXPECT_THROW(ogroup->add_options(opt1), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->add_options(opt1), CLI::OptionNotFound);
args = {"--option", "9"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--test1", "5", "--test2", "4", "--test3=5"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
std::string help = app.help();
auto exactloc = help.find("[At least 1");
auto oloc = help.find("--test1");
- EXPECT_NE(exactloc, std::string::npos);
- EXPECT_NE(oloc, std::string::npos);
- EXPECT_LT(exactloc, oloc);
+ CHECK(std::string::npos != exactloc);
+ CHECK(std::string::npos != oloc);
+ CHECK(oloc > exactloc);
}
-TEST_F(TApp, BasicOptionGroupAddFailures) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupAddFailures", "[optiongroup]") {
int res{0};
auto opt1 = app.add_option("--test1", res);
@@ -328,24 +324,24 @@ TEST_F(TApp, BasicOptionGroupAddFailures) {
app.add_option("--option", val2);
auto ogroup = app.add_option_group("clusters");
- EXPECT_THROW(ogroup->add_options(app.get_config_ptr()), CLI::OptionAlreadyAdded);
- EXPECT_THROW(ogroup->add_options(app.get_help_ptr()), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(ogroup->add_options(app.get_config_ptr()), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(ogroup->add_options(app.get_help_ptr()), CLI::OptionAlreadyAdded);
auto sub = app.add_subcommand("sub", "subcommand");
auto opt2 = sub->add_option("--option2", val2);
- EXPECT_THROW(ogroup->add_option(opt2), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->add_option(opt2), CLI::OptionNotFound);
- EXPECT_THROW(ogroup->add_options(nullptr), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->add_options(nullptr), CLI::OptionNotFound);
ogroup->add_option(opt1);
auto opt3 = app.add_option("--test1", res);
- EXPECT_THROW(ogroup->add_option(opt3), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(ogroup->add_option(opt3), CLI::OptionAlreadyAdded);
}
-TEST_F(TApp, BasicOptionGroupScrewedUpMove) {
+TEST_CASE_METHOD(TApp, "BasicOptionGroupScrewedUpMove", "[optiongroup]") {
int res{0};
auto opt1 = app.add_option("--test1", res);
@@ -356,25 +352,25 @@ TEST_F(TApp, BasicOptionGroupScrewedUpMove) {
auto ogroup = app.add_option_group("clusters");
ogroup->require_option();
auto ogroup2 = ogroup->add_option_group("clusters2");
- EXPECT_THROW(ogroup2->add_options(opt1, opt2), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup2->add_options(opt1, opt2), CLI::OptionNotFound);
CLI::Option_group EmptyGroup("description", "new group", nullptr);
- EXPECT_THROW(EmptyGroup.add_option(opt2), CLI::OptionNotFound);
- EXPECT_THROW(app._move_option(opt2, ogroup2), CLI::OptionNotFound);
+ CHECK_THROWS_AS(EmptyGroup.add_option(opt2), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app._move_option(opt2, ogroup2), CLI::OptionNotFound);
}
-TEST_F(TApp, InvalidOptions) {
+TEST_CASE_METHOD(TApp, "InvalidOptions", "[optiongroup]") {
auto ogroup = app.add_option_group("clusters");
CLI::Option *opt = nullptr;
- EXPECT_THROW(ogroup->excludes(opt), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->excludes(opt), CLI::OptionNotFound);
CLI::App *app_p = nullptr;
- EXPECT_THROW(ogroup->excludes(app_p), CLI::OptionNotFound);
- EXPECT_THROW(ogroup->excludes(ogroup), CLI::OptionNotFound);
- EXPECT_THROW(ogroup->add_option(opt), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->excludes(app_p), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->excludes(ogroup), CLI::OptionNotFound);
+ CHECK_THROWS_AS(ogroup->add_option(opt), CLI::OptionNotFound);
}
-TEST_F(TApp, OptionGroupInheritedOptionDefaults) {
+TEST_CASE_METHOD(TApp, "OptionGroupInheritedOptionDefaults", "[optiongroup]") {
app.option_defaults()->ignore_case();
auto ogroup = app.add_option_group("clusters");
int res{0};
@@ -382,8 +378,8 @@ TEST_F(TApp, OptionGroupInheritedOptionDefaults) {
args = {"--Test1", "5"};
run();
- EXPECT_EQ(res, 5);
- EXPECT_EQ(app.count_all(), 1u);
+ CHECK(5 == res);
+ CHECK(1u == app.count_all());
}
struct ManyGroups : public TApp {
@@ -425,48 +421,48 @@ struct ManyGroups : public TApp {
}
};
-TEST_F(ManyGroups, SingleGroup) {
+TEST_CASE_METHOD(ManyGroups, "SingleGroup", "[optiongroup]") {
// only 1 group can be used
main->require_option(1);
args = {"--name1", "test"};
run();
- EXPECT_EQ(name1, "test");
+ CHECK("test" == name1);
args = {"--name2", "test", "--val2", "tval"};
run();
- EXPECT_EQ(val2, "tval");
+ CHECK("tval" == val2);
args = {"--name1", "test", "--val2", "tval"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(ManyGroups, ExcludesGroup) {
+TEST_CASE_METHOD(ManyGroups, "ExcludesGroup", "[optiongroup]") {
// only 1 group can be used
g1->excludes(g2);
g1->excludes(g3);
args = {"--name1", "test"};
run();
- EXPECT_EQ(name1, "test");
+ CHECK("test" == name1);
args = {"--name1", "test", "--name2", "test2"};
- EXPECT_THROW(run(), CLI::ExcludesError);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
- EXPECT_TRUE(g1->remove_excludes(g2));
- EXPECT_NO_THROW(run());
- EXPECT_FALSE(g1->remove_excludes(g1));
- EXPECT_FALSE(g1->remove_excludes(g2));
+ CHECK(g1->remove_excludes(g2));
+ CHECK_NOTHROW(run());
+ CHECK(!g1->remove_excludes(g1));
+ CHECK(!g1->remove_excludes(g2));
}
-TEST_F(ManyGroups, NeedsGroup) {
+TEST_CASE_METHOD(ManyGroups, "NeedsGroup", "[optiongroup]") {
remove_required();
// all groups needed if g1 is used
g1->needs(g2);
g1->needs(g3);
args = {"--name1", "test"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
// other groups should run fine
args = {"--name2", "test2"};
@@ -474,11 +470,11 @@ TEST_F(ManyGroups, NeedsGroup) {
// all three groups should be fine
args = {"--name1", "test", "--name2", "test2", "--name3", "test3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
// test adding an option group with existing subcommands to an app
-TEST_F(TApp, ExistingSubcommandMatch) {
+TEST_CASE_METHOD(TApp, "ExistingSubcommandMatch", "[optiongroup]") {
auto sshared = std::make_shared<CLI::Option_group>("documenting the subcommand", "sub1g", nullptr);
auto s1 = sshared->add_subcommand("sub1");
auto o1 = sshared->add_option_group("opt1");
@@ -489,9 +485,9 @@ TEST_F(TApp, ExistingSubcommandMatch) {
try {
app.add_subcommand(sshared);
// this should throw the next line should never be reached
- EXPECT_FALSE(true);
+ CHECK(!true);
} catch(const CLI::OptionAlreadyAdded &oaa) {
- EXPECT_THAT(oaa.what(), HasSubstr("sub1"));
+ CHECK_THAT(oaa.what(), Contains("sub1"));
}
sshared->remove_subcommand(s1);
@@ -500,40 +496,40 @@ TEST_F(TApp, ExistingSubcommandMatch) {
try {
app.add_subcommand(sshared);
// this should throw the next line should never be reached
- EXPECT_FALSE(true);
+ CHECK(!true);
} catch(const CLI::OptionAlreadyAdded &oaa) {
- EXPECT_THAT(oaa.what(), HasSubstr("sub3"));
+ CHECK_THAT(oaa.what(), Contains("sub3"));
}
}
-TEST_F(ManyGroups, SingleGroupError) {
+TEST_CASE_METHOD(ManyGroups, "SingleGroupError", "[optiongroup]") {
// only 1 group can be used
main->require_option(1);
args = {"--name1", "test", "--name2", "test3"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(ManyGroups, AtMostOneGroup) {
+TEST_CASE_METHOD(ManyGroups, "AtMostOneGroup", "[optiongroup]") {
// only 1 group can be used
main->require_option(0, 1);
args = {"--name1", "test", "--name2", "test3"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManyGroups, AtLeastTwoGroups) {
+TEST_CASE_METHOD(ManyGroups, "AtLeastTwoGroups", "[optiongroup]") {
// only 1 group can be used
main->require_option(2, 0);
args = {"--name1", "test", "--name2", "test3"};
run();
args = {"--name1", "test"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(ManyGroups, BetweenOneAndTwoGroups) {
+TEST_CASE_METHOD(ManyGroups, "BetweenOneAndTwoGroups", "[optiongroup]") {
// only 1 group can be used
main->require_option(1, 2);
args = {"--name1", "test", "--name2", "test3"};
@@ -543,19 +539,19 @@ TEST_F(ManyGroups, BetweenOneAndTwoGroups) {
run();
args = {};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"--name1", "test", "--name2", "test3", "--name3=test3"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(ManyGroups, RequiredFirst) {
+TEST_CASE_METHOD(ManyGroups, "RequiredFirst", "[optiongroup]") {
// only 1 group can be used
remove_required();
g1->required();
- EXPECT_TRUE(g1->get_required());
- EXPECT_FALSE(g2->get_required());
+ CHECK(g1->get_required());
+ CHECK(!g2->get_required());
args = {"--name1", "test", "--name2", "test3"};
run();
@@ -563,32 +559,32 @@ TEST_F(ManyGroups, RequiredFirst) {
try {
run();
} catch(const CLI::RequiredError &re) {
- EXPECT_THAT(re.what(), HasSubstr("g1"));
+ CHECK_THAT(re.what(), Contains("g1"));
}
args = {"--name1", "test", "--name2", "test3", "--name3=test3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManyGroups, DisableFirst) {
+TEST_CASE_METHOD(ManyGroups, "DisableFirst", "[optiongroup]") {
// only 1 group can be used if remove_required not used
remove_required();
g1->disabled();
- EXPECT_TRUE(g1->get_disabled());
- EXPECT_FALSE(g2->get_disabled());
+ CHECK(g1->get_disabled());
+ CHECK(!g2->get_disabled());
args = {"--name2", "test"};
run();
args = {"--name1", "test", "--name2", "test3"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
g1->disabled(false);
args = {"--name1", "test", "--name2", "test3", "--name3=test3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManyGroups, SameSubcommand) {
+TEST_CASE_METHOD(ManyGroups, "SameSubcommand", "[optiongroup]") {
// only 1 group can be used if remove_required not used
remove_required();
auto sub1 = g1->add_subcommand("sub1")->disabled();
@@ -602,30 +598,30 @@ TEST_F(ManyGroups, SameSubcommand) {
run();
- EXPECT_TRUE(*sub1);
- EXPECT_TRUE(*sub2);
- EXPECT_TRUE(*sub3);
+ CHECK(*sub1);
+ CHECK(*sub2);
+ CHECK(*sub3);
auto subs = app.get_subcommands();
- EXPECT_EQ(subs.size(), 3u);
- EXPECT_EQ(subs[0], sub1);
- EXPECT_EQ(subs[1], sub2);
- EXPECT_EQ(subs[2], sub3);
+ CHECK(3u == subs.size());
+ CHECK(sub1 == subs[0]);
+ CHECK(sub2 == subs[1]);
+ CHECK(sub3 == subs[2]);
args = {"sub1", "sub1", "sub1", "sub1"};
// for the 4th and future ones they will route to the first one
run();
- EXPECT_EQ(sub1->count(), 2u);
- EXPECT_EQ(sub2->count(), 1u);
- EXPECT_EQ(sub3->count(), 1u);
+ CHECK(2u == sub1->count());
+ CHECK(1u == sub2->count());
+ CHECK(1u == sub3->count());
// subs should remain the same since the duplicate would not be registered there
subs = app.get_subcommands();
- EXPECT_EQ(subs.size(), 3u);
- EXPECT_EQ(subs[0], sub1);
- EXPECT_EQ(subs[1], sub2);
- EXPECT_EQ(subs[2], sub3);
+ CHECK(3u == subs.size());
+ CHECK(sub1 == subs[0]);
+ CHECK(sub2 == subs[1]);
+ CHECK(sub3 == subs[2]);
}
-TEST_F(ManyGroups, CallbackOrder) {
+TEST_CASE_METHOD(ManyGroups, "CallbackOrder", "[optiongroup]") {
// only 1 group can be used if remove_required not used
remove_required();
std::vector<int> callback_order;
@@ -635,61 +631,61 @@ TEST_F(ManyGroups, CallbackOrder) {
args = {"--name2", "test"};
run();
- EXPECT_EQ(callback_order, std::vector<int>({2, 3}));
+ CHECK(std::vector<int>({2, 3}) == callback_order);
callback_order.clear();
args = {"--name1", "t2", "--name2", "test"};
g2->immediate_callback();
run();
- EXPECT_EQ(callback_order, std::vector<int>({2, 1, 3}));
+ CHECK(std::vector<int>({2, 1, 3}) == callback_order);
callback_order.clear();
args = {"--name2", "test", "--name1", "t2"};
g2->immediate_callback(false);
run();
- EXPECT_EQ(callback_order, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == callback_order);
}
// Test the fallthrough for extra arguments
-TEST_F(ManyGroups, ExtrasFallDown) {
+TEST_CASE_METHOD(ManyGroups, "ExtrasFallDown", "[optiongroup]") {
// only 1 group can be used if remove_required not used
remove_required();
args = {"--test1", "--flag", "extra"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
main->allow_extras();
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
- EXPECT_EQ(app.remaining_size(true), 3u);
- EXPECT_EQ(main->remaining_size(), 3u);
+ CHECK(3u == app.remaining_size(true));
+ CHECK(3u == main->remaining_size());
std::vector<std::string> extras{"--test1", "--flag", "extra"};
- EXPECT_EQ(app.remaining(true), extras);
- EXPECT_EQ(main->remaining(), extras);
+ CHECK(extras == app.remaining(true));
+ CHECK(extras == main->remaining());
}
// Test the option Inheritance
-TEST_F(ManyGroups, Inheritance) {
+TEST_CASE_METHOD(ManyGroups, "Inheritance", "[optiongroup]") {
remove_required();
g1->ignore_case();
g1->ignore_underscore();
auto t2 = g1->add_subcommand("t2");
args = {"T2", "t_2"};
- EXPECT_TRUE(t2->get_ignore_underscore());
- EXPECT_TRUE(t2->get_ignore_case());
+ CHECK(t2->get_ignore_underscore());
+ CHECK(t2->get_ignore_case());
run();
- EXPECT_EQ(t2->count(), 2u);
+ CHECK(2u == t2->count());
}
-TEST_F(ManyGroups, Moving) {
+TEST_CASE_METHOD(ManyGroups, "Moving", "[optiongroup]") {
remove_required();
auto mg = app.add_option_group("maing");
mg->add_subcommand(g1);
mg->add_subcommand(g2);
- EXPECT_EQ(g1->get_parent(), mg);
- EXPECT_EQ(g2->get_parent(), mg);
- EXPECT_EQ(g3->get_parent(), main);
+ CHECK(mg == g1->get_parent());
+ CHECK(mg == g2->get_parent());
+ CHECK(main == g3->get_parent());
}
struct ManyGroupsPreTrigger : public ManyGroups {
@@ -704,35 +700,35 @@ struct ManyGroupsPreTrigger : public ManyGroups {
}
};
-TEST_F(ManyGroupsPreTrigger, PreTriggerTestsOptions) {
+TEST_CASE_METHOD(ManyGroupsPreTrigger, "PreTriggerTestsOptions", "[optiongroup]") {
args = {"--name1", "test", "--name2", "test3"};
run();
- EXPECT_EQ(triggerMain, 4u);
- EXPECT_EQ(trigger1, 2u);
- EXPECT_EQ(trigger2, 0u);
- EXPECT_EQ(trigger3, 27u);
+ CHECK(4u == triggerMain);
+ CHECK(2u == trigger1);
+ CHECK(0u == trigger2);
+ CHECK(27u == trigger3);
args = {"--name1", "test"};
trigger2 = 34u;
run();
- EXPECT_EQ(triggerMain, 2u);
- EXPECT_EQ(trigger1, 0u);
- EXPECT_EQ(trigger2, 34u);
+ CHECK(2u == triggerMain);
+ CHECK(0u == trigger1);
+ CHECK(34u == trigger2);
args = {};
run();
- EXPECT_EQ(triggerMain, 0u);
+ CHECK(0u == triggerMain);
args = {"--name1", "test", "--val1", "45", "--name2", "test3", "--name3=test3", "--val2=37"};
run();
- EXPECT_EQ(triggerMain, 8u);
- EXPECT_EQ(trigger1, 6u);
- EXPECT_EQ(trigger2, 2u);
- EXPECT_EQ(trigger3, 1u);
+ CHECK(8u == triggerMain);
+ CHECK(6u == trigger1);
+ CHECK(2u == trigger2);
+ CHECK(1u == trigger3);
}
-TEST_F(ManyGroupsPreTrigger, PreTriggerTestsPositionals) {
+TEST_CASE_METHOD(ManyGroupsPreTrigger, "PreTriggerTestsPositionals", "[optiongroup]") {
// only 1 group can be used
g1->add_option("pos1");
g2->add_option("pos2");
@@ -740,26 +736,26 @@ TEST_F(ManyGroupsPreTrigger, PreTriggerTestsPositionals) {
args = {"pos1"};
run();
- EXPECT_EQ(triggerMain, 1u);
- EXPECT_EQ(trigger1, 0u);
- EXPECT_EQ(trigger2, 34u);
- EXPECT_EQ(trigger3, 27u);
+ CHECK(1u == triggerMain);
+ CHECK(0u == trigger1);
+ CHECK(34u == trigger2);
+ CHECK(27u == trigger3);
args = {"pos1", "pos2"};
run();
- EXPECT_EQ(triggerMain, 2u);
- EXPECT_EQ(trigger1, 1u);
- EXPECT_EQ(trigger2, 0u);
+ CHECK(2u == triggerMain);
+ CHECK(1u == trigger1);
+ CHECK(0u == trigger2);
args = {"pos1", "pos2", "pos3"};
run();
- EXPECT_EQ(triggerMain, 3u);
- EXPECT_EQ(trigger1, 2u);
- EXPECT_EQ(trigger2, 1u);
- EXPECT_EQ(trigger3, 0u);
+ CHECK(3u == triggerMain);
+ CHECK(2u == trigger1);
+ CHECK(1u == trigger2);
+ CHECK(0u == trigger3);
}
-TEST_F(ManyGroupsPreTrigger, PreTriggerTestsSubcommand) {
+TEST_CASE_METHOD(ManyGroupsPreTrigger, "PreTriggerTestsSubcommand", "[optiongroup]") {
auto sub1 = g1->add_subcommand("sub1")->fallthrough();
g2->add_subcommand("sub2")->fallthrough();
@@ -769,23 +765,23 @@ TEST_F(ManyGroupsPreTrigger, PreTriggerTestsSubcommand) {
sub1->preparse_callback([&subtrigger](std::size_t count) { subtrigger = count; });
args = {"sub1"};
run();
- EXPECT_EQ(triggerMain, 1u);
- EXPECT_EQ(trigger1, 0u);
- EXPECT_EQ(trigger2, 34u);
- EXPECT_EQ(trigger3, 27u);
+ CHECK(1u == triggerMain);
+ CHECK(0u == trigger1);
+ CHECK(34u == trigger2);
+ CHECK(27u == trigger3);
args = {"sub1", "sub2"};
run();
- EXPECT_EQ(triggerMain, 2u);
- EXPECT_EQ(subtrigger, 1u);
- EXPECT_EQ(trigger1, 1u);
- EXPECT_EQ(trigger2, 0u);
+ CHECK(2u == triggerMain);
+ CHECK(1u == subtrigger);
+ CHECK(1u == trigger1);
+ CHECK(0u == trigger2);
args = {"sub2", "sub3", "--name1=test", "sub1"};
run();
- EXPECT_EQ(triggerMain, 4u);
- EXPECT_EQ(trigger1, 1u);
- EXPECT_EQ(trigger2, 3u);
- EXPECT_EQ(trigger3, 1u); // processes the first argument in group3 which includes the entire subcommand, which will
- // go until the sub1 command is given
+ CHECK(4u == triggerMain);
+ CHECK(1u == trigger1);
+ CHECK(3u == trigger2);
+ CHECK(1u == trigger3);
+ // go until the sub1 command is given
}
diff --git a/packages/CLI11/tests/OptionTypeTest.cpp b/packages/CLI11/tests/OptionTypeTest.cpp
index bbf71fdfb4a962984169895e6557b45fd2bc4805..a2f893bec598d56cbf17bd76c1de5c62b83eb19d 100644
--- a/packages/CLI11/tests/OptionTypeTest.cpp
+++ b/packages/CLI11/tests/OptionTypeTest.cpp
@@ -19,46 +19,44 @@
#include <unordered_set>
#include <vector>
-#include "gmock/gmock.h"
-
-TEST_F(TApp, OneStringAgain) {
+TEST_CASE_METHOD(TApp, "OneStringAgain", "[optiontype]") {
std::string str;
app.add_option("-s,--string", str);
args = {"--string", "mystring"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, OneStringFunction) {
+TEST_CASE_METHOD(TApp, "OneStringFunction", "[optiontype]") {
std::string str;
app.add_option_function<std::string>("-s,--string", [&str](const std::string &val) { str = val; });
args = {"--string", "mystring"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--string"));
- EXPECT_EQ(str, "mystring");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--string") == 1u);
+ CHECK("mystring" == str);
}
-TEST_F(TApp, doubleFunction) {
+TEST_CASE_METHOD(TApp, "doubleFunction", "[optiontype]") {
double res{0.0};
app.add_option_function<double>("--val", [&res](double val) { res = std::abs(val + 54); });
args = {"--val", "-354.356"};
run();
- EXPECT_EQ(res, 300.356);
+ CHECK(300.356 == res);
// get the original value as entered as an integer
- EXPECT_EQ(app["--val"]->as<float>(), -354.356f);
+ CHECK(-354.356f == app["--val"]->as<float>());
}
-TEST_F(TApp, doubleFunctionFail) {
+TEST_CASE_METHOD(TApp, "doubleFunctionFail", "[optiontype]") {
double res;
app.add_option_function<double>("--val", [&res](double val) { res = std::abs(val + 54); });
args = {"--val", "not_double"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, doubleVectorFunction) {
+TEST_CASE_METHOD(TApp, "doubleVectorFunction", "[optiontype]") {
std::vector<double> res;
app.add_option_function<std::vector<double>>("--val", [&res](const std::vector<double> &val) {
res = val;
@@ -66,12 +64,12 @@ TEST_F(TApp, doubleVectorFunction) {
});
args = {"--val", "5", "--val", "6", "--val", "7"};
run();
- EXPECT_EQ(res.size(), 3u);
- EXPECT_EQ(res[0], 10.0);
- EXPECT_EQ(res[2], 12.0);
+ CHECK(3u == res.size());
+ CHECK(10.0 == res[0]);
+ CHECK(12.0 == res[2]);
}
-TEST_F(TApp, doubleVectorFunctionFail) {
+TEST_CASE_METHOD(TApp, "doubleVectorFunctionFail", "[optiontype]") {
std::vector<double> res;
std::string vstring = "--val";
app.add_option_function<std::vector<double>>(vstring, [&res](const std::vector<double> &val) {
@@ -79,14 +77,14 @@ TEST_F(TApp, doubleVectorFunctionFail) {
std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
});
args = {"--val", "five", "--val", "nine", "--val", "7"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
// check that getting the results through the results function generates the same error
- EXPECT_THROW(app[vstring]->results(res), CLI::ConversionError);
+ CHECK_THROWS_AS(app[vstring]->results(res), CLI::ConversionError);
auto strvec = app[vstring]->as<std::vector<std::string>>();
- EXPECT_EQ(strvec.size(), 3u);
+ CHECK(3u == strvec.size());
}
-TEST_F(TApp, doubleVectorFunctionRunCallbackOnDefault) {
+TEST_CASE_METHOD(TApp, "doubleVectorFunctionRunCallbackOnDefault", "[optiontype]") {
std::vector<double> res;
auto opt = app.add_option_function<std::vector<double>>("--val", [&res](const std::vector<double> &val) {
res = val;
@@ -94,26 +92,26 @@ TEST_F(TApp, doubleVectorFunctionRunCallbackOnDefault) {
});
args = {"--val", "5", "--val", "6", "--val", "7"};
run();
- EXPECT_EQ(res.size(), 3u);
- EXPECT_EQ(res[0], 10.0);
- EXPECT_EQ(res[2], 12.0);
- EXPECT_FALSE(opt->get_run_callback_for_default());
+ CHECK(3u == res.size());
+ CHECK(10.0 == res[0]);
+ CHECK(12.0 == res[2]);
+ CHECK(!opt->get_run_callback_for_default());
opt->run_callback_for_default();
opt->default_val(std::vector<int>{2, 1, -2});
- EXPECT_EQ(res[0], 7.0);
- EXPECT_EQ(res[2], 3.0);
+ CHECK(7.0 == res[0]);
+ CHECK(3.0 == res[2]);
- EXPECT_THROW(opt->default_val("this is a string"), CLI::ConversionError);
+ CHECK_THROWS_AS(opt->default_val("this is a string"), CLI::ConversionError);
auto vec = opt->as<std::vector<double>>();
- ASSERT_EQ(vec.size(), 3U);
- EXPECT_EQ(vec[0], 5.0);
- EXPECT_EQ(vec[2], 7.0);
+ REQUIRE(3U == vec.size());
+ CHECK(5.0 == vec[0]);
+ CHECK(7.0 == vec[2]);
opt->check(CLI::Number);
opt->run_callback_for_default(false);
- EXPECT_THROW(opt->default_val("this is a string"), CLI::ValidationError);
+ CHECK_THROWS_AS(opt->default_val("this is a string"), CLI::ValidationError);
}
-TEST_F(TApp, BoolAndIntFlags) {
+TEST_CASE_METHOD(TApp, "BoolAndIntFlags", "[optiontype]") {
bool bflag{false};
int iflag{0};
@@ -125,24 +123,24 @@ TEST_F(TApp, BoolAndIntFlags) {
args = {"-b", "-i", "-u"};
run();
- EXPECT_TRUE(bflag);
- EXPECT_EQ(1, iflag);
- EXPECT_EQ((unsigned int)1, uflag);
+ CHECK(bflag);
+ CHECK(iflag == 1);
+ CHECK(uflag == (unsigned int)1);
args = {"-b", "-b"};
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(bflag);
+ REQUIRE_NOTHROW(run());
+ CHECK(bflag);
bflag = false;
args = {"-iiiuu"};
run();
- EXPECT_FALSE(bflag);
- EXPECT_EQ(3, iflag);
- EXPECT_EQ((unsigned int)2, uflag);
+ CHECK(!bflag);
+ CHECK(iflag == 3);
+ CHECK(uflag == (unsigned int)2);
}
-TEST_F(TApp, atomic_bool_flags) {
+TEST_CASE_METHOD(TApp, "atomic_bool_flags", "[optiontype]") {
std::atomic<bool> bflag{false};
std::atomic<int> iflag{0};
@@ -152,95 +150,95 @@ TEST_F(TApp, atomic_bool_flags) {
args = {"-b", "-i"};
run();
- EXPECT_TRUE(bflag.load());
- EXPECT_EQ(1, iflag.load());
+ CHECK(bflag.load());
+ CHECK(iflag.load() == 1);
args = {"-b", "-b"};
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(bflag.load());
+ REQUIRE_NOTHROW(run());
+ CHECK(bflag.load());
bflag = false;
args = {"-iii"};
run();
- EXPECT_FALSE(bflag.load());
- EXPECT_EQ(3, iflag.load());
+ CHECK(!bflag.load());
+ CHECK(iflag.load() == 3);
args = {"--int=notanumber"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, BoolOption) {
+TEST_CASE_METHOD(TApp, "BoolOption", "[optiontype]") {
bool bflag{false};
app.add_option("-b", bflag);
args = {"-b", "false"};
run();
- EXPECT_FALSE(bflag);
+ CHECK(!bflag);
args = {"-b", "1"};
run();
- EXPECT_TRUE(bflag);
+ CHECK(bflag);
args = {"-b", "-7"};
run();
- EXPECT_FALSE(bflag);
+ CHECK(!bflag);
// cause an out of bounds error internally
args = {"-b", "751615654161688126132138844896646748852"};
run();
- EXPECT_TRUE(bflag);
+ CHECK(bflag);
args = {"-b", "-751615654161688126132138844896646748852"};
run();
- EXPECT_FALSE(bflag);
+ CHECK(!bflag);
}
-TEST_F(TApp, atomic_int_option) {
+TEST_CASE_METHOD(TApp, "atomic_int_option", "[optiontype]") {
std::atomic<int> i{0};
auto aopt = app.add_option("-i,--int", i);
args = {"-i4"};
run();
- EXPECT_EQ(1u, app.count("--int"));
- EXPECT_EQ(1u, app.count("-i"));
- EXPECT_EQ(i, 4);
- EXPECT_EQ(app["-i"]->as<std::string>(), "4");
- EXPECT_EQ(app["--int"]->as<double>(), 4.0);
+ CHECK(app.count("--int") == 1u);
+ CHECK(app.count("-i") == 1u);
+ CHECK(4 == i);
+ CHECK("4" == app["-i"]->as<std::string>());
+ CHECK(4.0 == app["--int"]->as<double>());
args = {"--int", "notAnInt"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
aopt->expected(0, 1);
args = {"--int"};
run();
- EXPECT_EQ(i, 0);
+ CHECK(0 == i);
}
-TEST_F(TApp, CharOption) {
+TEST_CASE_METHOD(TApp, "CharOption", "[optiontype]") {
char c1{'t'};
app.add_option("-c", c1);
args = {"-c", "g"};
run();
- EXPECT_EQ(c1, 'g');
+ CHECK('g' == c1);
args = {"-c", "1"};
run();
- EXPECT_EQ(c1, '1');
+ CHECK('1' == c1);
args = {"-c", "77"};
run();
- EXPECT_EQ(c1, 77);
+ CHECK(77 == c1);
// convert hex for digit
args = {"-c", "0x44"};
run();
- EXPECT_EQ(c1, 0x44);
+ CHECK(0x44 == c1);
args = {"-c", "751615654161688126132138844896646748852"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, vectorDefaults) {
+TEST_CASE_METHOD(TApp, "vectorDefaults", "[optiontype]") {
std::vector<int> vals{4, 5};
auto opt = app.add_option("--long", vals, "", true);
@@ -248,30 +246,30 @@ TEST_F(TApp, vectorDefaults) {
run();
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
args.clear();
run();
auto res = app["--long"]->as<std::vector<int>>();
- EXPECT_EQ(res, std::vector<int>({4, 5}));
+ CHECK(std::vector<int>({4, 5}) == res);
app.clear();
opt->expected(1)->take_last();
res = app["--long"]->as<std::vector<int>>();
- EXPECT_EQ(res, std::vector<int>({5}));
+ CHECK(std::vector<int>({5}) == res);
opt->take_first();
res = app["--long"]->as<std::vector<int>>();
- EXPECT_EQ(res, std::vector<int>({4}));
+ CHECK(std::vector<int>({4}) == res);
opt->expected(0, 1)->take_last();
run();
- EXPECT_EQ(res, std::vector<int>({4}));
+ CHECK(std::vector<int>({4}) == res);
res = app["--long"]->as<std::vector<int>>();
- EXPECT_EQ(res, std::vector<int>({5}));
+ CHECK(std::vector<int>({5}) == res);
}
-TEST_F(TApp, CallbackBoolFlags) {
+TEST_CASE_METHOD(TApp, "CallbackBoolFlags", "[optiontype]") {
bool value{false};
@@ -280,24 +278,24 @@ TEST_F(TApp, CallbackBoolFlags) {
auto cback = app.add_flag_callback("--val", func);
args = {"--val"};
run();
- EXPECT_TRUE(value);
+ CHECK(value);
value = false;
args = {"--val=false"};
run();
- EXPECT_FALSE(value);
+ CHECK(!value);
- EXPECT_THROW(app.add_flag_callback("hi", func), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_flag_callback("hi", func), CLI::IncorrectConstruction);
cback->multi_option_policy(CLI::MultiOptionPolicy::Throw);
args = {"--val", "--val=false"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, pair_check) {
+TEST_CASE_METHOD(TApp, "pair_check", "[optiontype]") {
std::string myfile{"pair_check_file.txt"};
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
+ CHECK(ok);
- EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
+ CHECK(CLI::ExistingFile(myfile).empty());
std::pair<std::string, int> findex;
auto v0 = CLI::ExistingFile;
@@ -308,112 +306,112 @@ TEST_F(TApp, pair_check) {
args = {"--file", myfile, "2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
- EXPECT_EQ(findex.first, myfile);
- EXPECT_EQ(findex.second, 2);
+ CHECK(myfile == findex.first);
+ CHECK(2 == findex.second);
args = {"--file", myfile, "-3"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--file", myfile, "2"};
std::remove(myfile.c_str());
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
// this will require that modifying the multi-option policy for tuples be allowed which it isn't at present
-TEST_F(TApp, pair_check_take_first) {
+TEST_CASE_METHOD(TApp, "pair_check_take_first", "[optiontype]") {
std::string myfile{"pair_check_file2.txt"};
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
- EXPECT_TRUE(ok);
+ CHECK(ok);
- EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
+ CHECK(CLI::ExistingFile(myfile).empty());
std::pair<std::string, int> findex;
auto opt = app.add_option("--file", findex)->check(CLI::ExistingFile)->check(CLI::PositiveNumber);
- EXPECT_THROW(opt->get_validator(3), CLI::OptionNotFound);
+ CHECK_THROWS_AS(opt->get_validator(3), CLI::OptionNotFound);
opt->get_validator(0)->application_index(0);
opt->get_validator(1)->application_index(1);
opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
args = {"--file", "not_a_file.txt", "-16", "--file", myfile, "2"};
// should only check the last one
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
- EXPECT_EQ(findex.first, myfile);
- EXPECT_EQ(findex.second, 2);
+ CHECK(myfile == findex.first);
+ CHECK(2 == findex.second);
opt->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst);
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, VectorFixedString) {
+TEST_CASE_METHOD(TApp, "VectorFixedString", "[optiontype]") {
std::vector<std::string> strvec;
std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
CLI::Option *opt = app.add_option("-s,--string", strvec)->expected(3);
- EXPECT_EQ(3, opt->get_expected());
+ CHECK(opt->get_expected() == 3);
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
- EXPECT_EQ(answer, strvec);
+ CHECK(app.count("--string") == 3u);
+ CHECK(strvec == answer);
}
-TEST_F(TApp, VectorDefaultedFixedString) {
+TEST_CASE_METHOD(TApp, "VectorDefaultedFixedString", "[optiontype]") {
std::vector<std::string> strvec{"one"};
std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
CLI::Option *opt = app.add_option("-s,--string", strvec, "")->expected(3)->capture_default_str();
- EXPECT_EQ(3, opt->get_expected());
+ CHECK(opt->get_expected() == 3);
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
- EXPECT_EQ(answer, strvec);
+ CHECK(app.count("--string") == 3u);
+ CHECK(strvec == answer);
}
-TEST_F(TApp, VectorIndexedValidator) {
+TEST_CASE_METHOD(TApp, "VectorIndexedValidator", "[optiontype]") {
std::vector<int> vvec;
CLI::Option *opt = app.add_option("-v", vvec);
args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
run();
- EXPECT_EQ(4u, app.count("-v"));
- EXPECT_EQ(4u, vvec.size());
+ CHECK(app.count("-v") == 4u);
+ CHECK(vvec.size() == 4u);
opt->check(CLI::PositiveNumber.application_index(0));
opt->check((!CLI::PositiveNumber).application_index(1));
- EXPECT_NO_THROW(run());
- EXPECT_EQ(4u, vvec.size());
+ CHECK_NOTHROW(run());
+ CHECK(vvec.size() == 4u);
// v[3] would be negative
opt->check(CLI::PositiveNumber.application_index(3));
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, VectorUnlimString) {
+TEST_CASE_METHOD(TApp, "VectorUnlimString", "[optiontype]") {
std::vector<std::string> strvec;
std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
CLI::Option *opt = app.add_option("-s,--string", strvec);
- EXPECT_EQ(1, opt->get_expected());
- EXPECT_EQ(CLI::detail::expected_max_vector_size, opt->get_expected_max());
+ CHECK(opt->get_expected() == 1);
+ CHECK(opt->get_expected_max() == CLI::detail::expected_max_vector_size);
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
- EXPECT_EQ(answer, strvec);
+ CHECK(app.count("--string") == 3u);
+ CHECK(strvec == answer);
args = {"-s", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
- EXPECT_EQ(answer, strvec);
+ CHECK(app.count("--string") == 3u);
+ CHECK(strvec == answer);
}
// From https://github.com/CLIUtils/CLI11/issues/420
-TEST_F(TApp, stringLikeTests) {
+TEST_CASE_METHOD(TApp, "stringLikeTests", "[optiontype]") {
struct nType {
explicit nType(const std::string &a_value) : m_value{a_value} {}
@@ -426,14 +424,14 @@ TEST_F(TApp, stringLikeTests) {
app.add_option("--type", m_type, "type")->capture_default_str();
run();
- EXPECT_EQ(app["--type"]->as<std::string>(), "op str");
+ CHECK("op str" == app["--type"]->as<std::string>());
args = {"--type", "bca"};
run();
- EXPECT_EQ(std::string(m_type), "op str");
- EXPECT_EQ(m_type.m_value, "bca");
+ CHECK("op str" == std::string(m_type));
+ CHECK("bca" == m_type.m_value);
}
-TEST_F(TApp, VectorExpectedRange) {
+TEST_CASE_METHOD(TApp, "VectorExpectedRange", "[optiontype]") {
std::vector<std::string> strvec;
CLI::Option *opt = app.add_option("--string", strvec);
@@ -441,47 +439,47 @@ TEST_F(TApp, VectorExpectedRange) {
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
+ CHECK(app.count("--string") == 3u);
args = {"--string", "mystring"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"--string", "mystring", "mystring2", "string2", "--string", "string4", "string5"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
- EXPECT_EQ(opt->get_expected_max(), 4);
- EXPECT_EQ(opt->get_expected_min(), 2);
+ CHECK(4 == opt->get_expected_max());
+ CHECK(2 == opt->get_expected_min());
opt->expected(4, 2); // just test the handling of reversed arguments
- EXPECT_EQ(opt->get_expected_max(), 4);
- EXPECT_EQ(opt->get_expected_min(), 2);
+ CHECK(4 == opt->get_expected_max());
+ CHECK(2 == opt->get_expected_min());
opt->expected(-5);
- EXPECT_EQ(opt->get_expected_max(), 5);
- EXPECT_EQ(opt->get_expected_min(), 5);
+ CHECK(5 == opt->get_expected_max());
+ CHECK(5 == opt->get_expected_min());
opt->expected(-5, 7);
- EXPECT_EQ(opt->get_expected_max(), 7);
- EXPECT_EQ(opt->get_expected_min(), 5);
+ CHECK(7 == opt->get_expected_max());
+ CHECK(5 == opt->get_expected_min());
}
-TEST_F(TApp, VectorFancyOpts) {
+TEST_CASE_METHOD(TApp, "VectorFancyOpts", "[optiontype]") {
std::vector<std::string> strvec;
std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
CLI::Option *opt = app.add_option("-s,--string", strvec)->required()->expected(3);
- EXPECT_EQ(3, opt->get_expected());
+ CHECK(opt->get_expected() == 3);
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
- EXPECT_EQ(3u, app.count("--string"));
- EXPECT_EQ(answer, strvec);
+ CHECK(app.count("--string") == 3u);
+ CHECK(strvec == answer);
args = {"one", "two"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
- EXPECT_THROW(run(), CLI::ParseError);
+ CHECK_THROWS_AS(run(), CLI::ParseError);
}
// #87
-TEST_F(TApp, CustomDoubleOption) {
+TEST_CASE_METHOD(TApp, "CustomDoubleOption", "[optiontype]") {
std::pair<int, double> custom_opt;
@@ -494,12 +492,12 @@ TEST_F(TApp, CustomDoubleOption) {
args = {"12", "1.5"};
run();
- EXPECT_EQ(custom_opt.first, 12);
- EXPECT_DOUBLE_EQ(custom_opt.second, 1.5);
+ CHECK(12 == custom_opt.first);
+ CHECK(1.5 == Approx(custom_opt.second));
}
// now with tuple support this is possible
-TEST_F(TApp, CustomDoubleOptionAlt) {
+TEST_CASE_METHOD(TApp, "CustomDoubleOptionAlt", "[optiontype]") {
std::pair<int, double> custom_opt;
@@ -508,12 +506,12 @@ TEST_F(TApp, CustomDoubleOptionAlt) {
args = {"12", "1.5"};
run();
- EXPECT_EQ(custom_opt.first, 12);
- EXPECT_DOUBLE_EQ(custom_opt.second, 1.5);
+ CHECK(12 == custom_opt.first);
+ CHECK(1.5 == Approx(custom_opt.second));
}
// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorPair) {
+TEST_CASE_METHOD(TApp, "vectorPair", "[optiontype]") {
std::vector<std::pair<int, std::string>> custom_opt;
@@ -522,21 +520,21 @@ TEST_F(TApp, vectorPair) {
args = {"--dict", "1", "str1", "--dict", "3", "str3"};
run();
- ASSERT_EQ(custom_opt.size(), 2u);
- EXPECT_EQ(custom_opt[0].first, 1);
- EXPECT_EQ(custom_opt[1].second, "str3");
+ REQUIRE(2u == custom_opt.size());
+ CHECK(1 == custom_opt[0].first);
+ CHECK("str3" == custom_opt[1].second);
args = {"--dict", "1", "str1", "--dict", "3", "str3", "--dict", "-1", "str4"};
run();
- ASSERT_EQ(custom_opt.size(), 3u);
- EXPECT_EQ(custom_opt[2].first, -1);
- EXPECT_EQ(custom_opt[2].second, "str4");
+ REQUIRE(3u == custom_opt.size());
+ CHECK(-1 == custom_opt[2].first);
+ CHECK("str4" == custom_opt[2].second);
opt->check(CLI::PositiveNumber.application_index(0));
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, vectorPairFail) {
+TEST_CASE_METHOD(TApp, "vectorPairFail", "[optiontype]") {
std::vector<std::pair<int, std::string>> custom_opt;
@@ -544,46 +542,46 @@ TEST_F(TApp, vectorPairFail) {
args = {"--dict", "1", "str1", "--dict", "str3", "1"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, vectorPairTypeRange) {
+TEST_CASE_METHOD(TApp, "vectorPairTypeRange", "[optiontype]") {
std::vector<std::pair<int, std::string>> custom_opt;
auto opt = app.add_option("--dict", custom_opt);
opt->type_size(2, 1); // just test switched arguments
- EXPECT_EQ(opt->get_type_size_min(), 1);
- EXPECT_EQ(opt->get_type_size_max(), 2);
+ CHECK(1 == opt->get_type_size_min());
+ CHECK(2 == opt->get_type_size_max());
args = {"--dict", "1", "str1", "--dict", "3", "str3"};
run();
- ASSERT_EQ(custom_opt.size(), 2u);
- EXPECT_EQ(custom_opt[0].first, 1);
- EXPECT_EQ(custom_opt[1].second, "str3");
+ REQUIRE(2u == custom_opt.size());
+ CHECK(1 == custom_opt[0].first);
+ CHECK("str3" == custom_opt[1].second);
args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
run();
- ASSERT_EQ(custom_opt.size(), 3u);
- EXPECT_TRUE(custom_opt[1].second.empty());
- EXPECT_EQ(custom_opt[2].first, -1);
- EXPECT_EQ(custom_opt[2].second, "str4");
+ REQUIRE(3u == custom_opt.size());
+ CHECK(custom_opt[1].second.empty());
+ CHECK(-1 == custom_opt[2].first);
+ CHECK("str4" == custom_opt[2].second);
opt->type_size(-2, -1); // test negative arguments
- EXPECT_EQ(opt->get_type_size_min(), 1);
- EXPECT_EQ(opt->get_type_size_max(), 2);
+ CHECK(1 == opt->get_type_size_min());
+ CHECK(2 == opt->get_type_size_max());
// this type size spec should run exactly as before
run();
- ASSERT_EQ(custom_opt.size(), 3u);
- EXPECT_TRUE(custom_opt[1].second.empty());
- EXPECT_EQ(custom_opt[2].first, -1);
- EXPECT_EQ(custom_opt[2].second, "str4");
+ REQUIRE(3u == custom_opt.size());
+ CHECK(custom_opt[1].second.empty());
+ CHECK(-1 == custom_opt[2].first);
+ CHECK("str4" == custom_opt[2].second);
}
// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorTuple) {
+TEST_CASE_METHOD(TApp, "vectorTuple", "[optiontype]") {
std::vector<std::tuple<int, std::string, double>> custom_opt;
@@ -592,28 +590,28 @@ TEST_F(TApp, vectorTuple) {
args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
run();
- ASSERT_EQ(custom_opt.size(), 2u);
- EXPECT_EQ(std::get<0>(custom_opt[0]), 1);
- EXPECT_EQ(std::get<1>(custom_opt[1]), "str3");
- EXPECT_EQ(std::get<2>(custom_opt[1]), 2.7);
+ REQUIRE(2u == custom_opt.size());
+ CHECK(1 == std::get<0>(custom_opt[0]));
+ CHECK("str3" == std::get<1>(custom_opt[1]));
+ CHECK(2.7 == std::get<2>(custom_opt[1]));
args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
run();
- ASSERT_EQ(custom_opt.size(), 3u);
- EXPECT_EQ(std::get<0>(custom_opt[2]), -1);
- EXPECT_EQ(std::get<1>(custom_opt[2]), "str4");
- EXPECT_EQ(std::get<2>(custom_opt[2]), -1.87);
+ REQUIRE(3u == custom_opt.size());
+ CHECK(-1 == std::get<0>(custom_opt[2]));
+ CHECK("str4" == std::get<1>(custom_opt[2]));
+ CHECK(-1.87 == std::get<2>(custom_opt[2]));
opt->check(CLI::PositiveNumber.application_index(0));
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args.back() = "haha";
args[9] = "45";
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorVector) {
+TEST_CASE_METHOD(TApp, "vectorVector", "[optiontype]") {
std::vector<std::vector<int>> custom_opt;
@@ -622,34 +620,34 @@ TEST_F(TApp, vectorVector) {
args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
run();
- ASSERT_EQ(custom_opt.size(), 2u);
- EXPECT_EQ(custom_opt[0].size(), 3u);
- EXPECT_EQ(custom_opt[1].size(), 2u);
+ REQUIRE(2u == custom_opt.size());
+ CHECK(3u == custom_opt[0].size());
+ CHECK(2u == custom_opt[1].size());
args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
"3", "3", "3", "3", "3", "3", "3", "3", "3", "-3"};
run();
- ASSERT_EQ(custom_opt.size(), 4u);
- EXPECT_EQ(custom_opt[0].size(), 3u);
- EXPECT_EQ(custom_opt[1].size(), 2u);
- EXPECT_EQ(custom_opt[2].size(), 1u);
- EXPECT_EQ(custom_opt[3].size(), 10u);
+ REQUIRE(4u == custom_opt.size());
+ CHECK(3u == custom_opt[0].size());
+ CHECK(2u == custom_opt[1].size());
+ CHECK(1u == custom_opt[2].size());
+ CHECK(10u == custom_opt[3].size());
opt->check(CLI::PositiveNumber.application_index(9));
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args.pop_back();
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args.back() = "haha";
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
args = {"--dict", "1", "2", "4", "%%", "3", "1", "%%", "3", "%%", "3", "3", "3", "3", "3", "3", "3", "3", "3", "3"};
run();
- ASSERT_EQ(custom_opt.size(), 4u);
+ REQUIRE(4u == custom_opt.size());
}
// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorVectorFixedSize) {
+TEST_CASE_METHOD(TApp, "vectorVectorFixedSize", "[optiontype]") {
std::vector<std::vector<int>> custom_opt;
@@ -658,21 +656,21 @@ TEST_F(TApp, vectorVectorFixedSize) {
args = {"--dict", "1", "2", "4", "3", "--dict", "3", "1", "2", "8"};
run();
- ASSERT_EQ(custom_opt.size(), 2u);
- EXPECT_EQ(custom_opt[0].size(), 4u);
- EXPECT_EQ(custom_opt[1].size(), 4u);
+ REQUIRE(2u == custom_opt.size());
+ CHECK(4u == custom_opt[0].size());
+ CHECK(4u == custom_opt[1].size());
args = {"--dict", "1", "2", "4", "--dict", "3", "1", "7", "6"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
// this should reset it
opt->type_size(CLI::detail::expected_max_vector_size);
opt->type_size(1, CLI::detail::expected_max_vector_size);
- EXPECT_NO_THROW(run());
- ASSERT_EQ(custom_opt.size(), 2U);
+ CHECK_NOTHROW(run());
+ REQUIRE(2U == custom_opt.size());
}
// now with independent type sizes and expected this is possible
-TEST_F(TApp, tuplePair) {
+TEST_CASE_METHOD(TApp, "tuplePair", "[optiontype]") {
std::tuple<std::pair<int, double>> custom_opt;
app.add_option("--pr", custom_opt);
@@ -680,11 +678,11 @@ TEST_F(TApp, tuplePair) {
args = {"--pr", "1", "2"};
run();
- EXPECT_EQ(std::get<0>(custom_opt).first, 1);
- EXPECT_EQ(std::get<0>(custom_opt).second, 2.0);
+ CHECK(1 == std::get<0>(custom_opt).first);
+ CHECK(2.0 == std::get<0>(custom_opt).second);
}
// now with independent type sizes and expected this is possible
-TEST_F(TApp, tupleintPair) {
+TEST_CASE_METHOD(TApp, "tupleintPair", "[optiontype]") {
std::tuple<int, std::pair<int, double>> custom_opt;
app.add_option("--pr", custom_opt);
@@ -692,9 +690,9 @@ TEST_F(TApp, tupleintPair) {
args = {"--pr", "3", "1", "2"};
run();
- EXPECT_EQ(std::get<0>(custom_opt), 3);
- EXPECT_EQ(std::get<1>(custom_opt).first, 1);
- EXPECT_EQ(std::get<1>(custom_opt).second, 2.0);
+ CHECK(3 == std::get<0>(custom_opt));
+ CHECK(1 == std::get<1>(custom_opt).first);
+ CHECK(2.0 == std::get<1>(custom_opt).second);
}
static_assert(CLI::detail::is_mutable_container<std::set<std::string>>::value, "set should be a container");
@@ -719,66 +717,54 @@ static_assert(CLI::detail::type_count<std::list<std::pair<int, std::string>>>::v
static_assert(CLI::detail::type_count<std::map<std::string, std::pair<int, std::string>>>::value == 3,
"map<string,pair<int,string>> should have a type size of 3");
-template <class T> class TApp_container_single : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_single() : TApp() {}
-};
-
-using containerTypes_single =
- ::testing::Types<std::vector<int>, std::deque<int>, std::set<int>, std::list<int>, std::unordered_set<int>>;
-
-TYPED_TEST_SUITE(TApp_container_single, containerTypes_single, );
-
-TYPED_TEST(TApp_container_single, containerInt) {
-
- auto &cv = TApp_container_single<TypeParam>::cval;
- CLI::Option *opt = (TApp::app).add_option("-v", cv);
-
- TApp::args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
- TApp::run();
- EXPECT_EQ(4u, (TApp::app).count("-v"));
- EXPECT_EQ(4u, cv.size());
+TEMPLATE_TEST_CASE("Container int single",
+ "[optiontype]",
+ std::vector<int>,
+ std::deque<int>,
+ std::set<int>,
+ std::list<int>,
+ std::unordered_set<int>) {
+ TApp tapp;
+ TestType cv;
+
+ CLI::Option *opt = tapp.app.add_option("-v", cv);
+
+ tapp.args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
+ tapp.run();
+ CHECK(tapp.app.count("-v") == 4u);
+ CHECK(cv.size() == 4u);
opt->check(CLI::PositiveNumber.application_index(0));
opt->check((!CLI::PositiveNumber).application_index(1));
- EXPECT_NO_THROW(TApp::run());
- EXPECT_EQ(4u, cv.size());
+ CHECK_NOTHROW(tapp.run());
+ CHECK(cv.size() == 4u);
// v[3] would be negative
opt->check(CLI::PositiveNumber.application_index(3));
- EXPECT_THROW(TApp::run(), CLI::ValidationError);
+ CHECK_THROWS_AS(tapp.run(), CLI::ValidationError);
}
-template <class T> class TApp_container_pair : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_pair() : TApp() {}
-};
-
using isp = std::pair<int, std::string>;
-using containerTypes_pair = ::testing::Types<std::vector<isp>,
- std::deque<isp>,
- std::set<isp>,
- std::list<isp>,
- std::map<int, std::string>,
- std::unordered_map<int, std::string>>;
-TYPED_TEST_SUITE(TApp_container_pair, containerTypes_pair, );
+TEMPLATE_TEST_CASE("Container pair",
+ "[optiontype]",
+ std::vector<isp>,
+ std::deque<isp>,
+ std::set<isp>,
+ std::list<isp>,
+ (std::map<int, std::string>),
+ (std::unordered_map<int, std::string>)) {
+ TApp tapp;
+ TestType cv;
-TYPED_TEST(TApp_container_pair, containerPair) {
+ (tapp.app).add_option("--dict", cv);
- auto &cv = TApp_container_pair<TypeParam>::cval;
- (TApp::app).add_option("--dict", cv);
+ tapp.args = {"--dict", "1", "str1", "--dict", "3", "str3"};
- TApp::args = {"--dict", "1", "str1", "--dict", "3", "str3"};
+ tapp.run();
+ CHECK(2u == cv.size());
- TApp::run();
- EXPECT_EQ(cv.size(), 2u);
-
- TApp::args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
- TApp::run();
- EXPECT_EQ(cv.size(), 3u);
+ tapp.args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
+ tapp.run();
+ CHECK(3u == cv.size());
}
template <class T> class TApp_container_tuple : public TApp {
@@ -789,28 +775,28 @@ template <class T> class TApp_container_tuple : public TApp {
};
using tup_obj = std::tuple<int, std::string, double>;
-using containerTypes_tuple = ::testing::Types<std::vector<tup_obj>,
- std::deque<tup_obj>,
- std::set<tup_obj>,
- std::list<tup_obj>,
- std::map<int, std::pair<std::string, double>>,
- std::unordered_map<int, std::tuple<std::string, double>>>;
-
-TYPED_TEST_SUITE(TApp_container_tuple, containerTypes_tuple, );
-TYPED_TEST(TApp_container_tuple, containerTuple) {
+TEMPLATE_TEST_CASE("Container tuple",
+ "[optiontype]",
+ std::vector<tup_obj>,
+ std::deque<tup_obj>,
+ std::set<tup_obj>,
+ std::list<tup_obj>,
+ (std::map<int, std::pair<std::string, double>>),
+ (std::unordered_map<int, std::tuple<std::string, double>>)) {
+ TApp tapp;
+ TestType cv;
- auto &cv = TApp_container_tuple<TypeParam>::cval;
- (TApp::app).add_option("--dict", cv);
+ (tapp.app).add_option("--dict", cv);
- TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
+ tapp.args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
- TApp::run();
- EXPECT_EQ(cv.size(), 2u);
+ tapp.run();
+ CHECK(2u == cv.size());
- TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
- TApp::run();
- EXPECT_EQ(cv.size(), 3u);
+ tapp.args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
+ tapp.run();
+ CHECK(3u == cv.size());
}
using icontainer1 = std::vector<int>;
@@ -818,45 +804,37 @@ using icontainer2 = std::list<int>;
using icontainer3 = std::set<int>;
using icontainer4 = std::pair<int, std::vector<int>>;
-using containerTypes_container = ::testing::Types<std::vector<icontainer1>,
- std::list<icontainer1>,
- std::set<icontainer1>,
- std::deque<icontainer1>,
- std::vector<icontainer2>,
- std::list<icontainer2>,
- std::set<icontainer2>,
- std::deque<icontainer2>,
- std::vector<icontainer3>,
- std::list<icontainer3>,
- std::set<icontainer3>,
- std::deque<icontainer3>>;
-
-template <class T> class TApp_container_container : public TApp {
- public:
- using container_type = T;
- container_type cval{};
- TApp_container_container() : TApp() {}
-};
-
-TYPED_TEST_SUITE(TApp_container_container, containerTypes_container, );
-
-TYPED_TEST(TApp_container_container, containerContainer) {
+TEMPLATE_TEST_CASE("Container container",
+ "[optiontype]",
+ std::vector<icontainer1>,
+ std::list<icontainer1>,
+ std::set<icontainer1>,
+ std::deque<icontainer1>,
+ std::vector<icontainer2>,
+ std::list<icontainer2>,
+ std::set<icontainer2>,
+ std::deque<icontainer2>,
+ std::vector<icontainer3>,
+ std::list<icontainer3>,
+ std::set<icontainer3>,
+ std::deque<icontainer3>) {
+ TApp tapp;
+ TestType cv;
- auto &cv = TApp_container_container<TypeParam>::cval;
- (TApp::app).add_option("--dict", cv);
+ (tapp.app).add_option("--dict", cv);
- TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
+ tapp.args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
- TApp::run();
- EXPECT_EQ(cv.size(), 2u);
+ tapp.run();
+ CHECK(2u == cv.size());
- TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
- "3", "3", "3", "3", "3", "3", "3", "3", "3", "-3"};
- TApp::run();
- EXPECT_EQ(cv.size(), 4u);
+ tapp.args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
+ "3", "3", "3", "3", "3", "3", "3", "3", "3", "-3"};
+ tapp.run();
+ CHECK(4u == cv.size());
}
-TEST_F(TApp, containerContainer) {
+TEST_CASE_METHOD(TApp, "containerContainer", "[optiontype]") {
std::vector<icontainer4> cv;
app.add_option("--dict", cv);
@@ -864,15 +842,15 @@ TEST_F(TApp, containerContainer) {
args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
run();
- EXPECT_EQ(cv.size(), 2u);
+ CHECK(2u == cv.size());
args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "", "--dict",
"3", "3", "3", "3", "3", "3", "3", "3", "3", "-3"};
run();
- EXPECT_EQ(cv.size(), 4u);
+ CHECK(4u == cv.size());
}
-TEST_F(TApp, unknownContainerWrapper) {
+TEST_CASE_METHOD(TApp, "unknownContainerWrapper", "[optiontype]") {
class vopt {
public:
@@ -887,14 +865,14 @@ TEST_F(TApp, unknownContainerWrapper) {
args = {"--vv", "1", "2", "4"};
run();
- EXPECT_EQ(cv.val_.size(), 3u);
+ CHECK(3u == cv.val_.size());
args = {"--vv", ""};
run();
- EXPECT_TRUE(cv.val_.empty());
+ CHECK(cv.val_.empty());
}
-TEST_F(TApp, tupleTwoVectors) {
+TEST_CASE_METHOD(TApp, "tupleTwoVectors", "[optiontype]") {
std::tuple<std::vector<int>, std::vector<int>> cv;
app.add_option("--vv", cv);
@@ -902,17 +880,17 @@ TEST_F(TApp, tupleTwoVectors) {
args = {"--vv", "1", "2", "4"};
run();
- EXPECT_EQ(std::get<0>(cv).size(), 3U);
- EXPECT_TRUE(std::get<1>(cv).empty());
+ CHECK(3U == std::get<0>(cv).size());
+ CHECK(std::get<1>(cv).empty());
args = {"--vv", "1", "2", "%%", "4", "4", "5"};
run();
- EXPECT_EQ(std::get<0>(cv).size(), 2U);
- EXPECT_EQ(std::get<1>(cv).size(), 3U);
+ CHECK(2U == std::get<0>(cv).size());
+ CHECK(3U == std::get<1>(cv).size());
}
-TEST_F(TApp, vectorSingleArg) {
+TEST_CASE_METHOD(TApp, "vectorSingleArg", "[optiontype]") {
std::vector<int> cv;
app.add_option("-c", cv)->allow_extra_args(false);
@@ -921,11 +899,11 @@ TEST_F(TApp, vectorSingleArg) {
args = {"-c", "1", "-c", "2", "4"};
run();
- EXPECT_EQ(cv.size(), 2U);
- EXPECT_EQ(extra, "4");
+ CHECK(2U == cv.size());
+ CHECK("4" == extra);
}
-TEST_F(TApp, vectorDoubleArg) {
+TEST_CASE_METHOD(TApp, "vectorDoubleArg", "[optiontype]") {
std::vector<std::pair<int, std::string>> cv;
app.add_option("-c", cv)->allow_extra_args(false);
@@ -934,6 +912,6 @@ TEST_F(TApp, vectorDoubleArg) {
args = {"-c", "1", "bob", "-c", "2", "apple", "4", "key"};
run();
- EXPECT_EQ(cv.size(), 2U);
- EXPECT_EQ(extras.size(), 2U);
+ CHECK(2U == cv.size());
+ CHECK(2U == extras.size());
}
diff --git a/packages/CLI11/tests/OptionalTest.cpp b/packages/CLI11/tests/OptionalTest.cpp
index 51f159aa69975b0dff22ed06ef315f0be8797e76..4d8da020b67b1f3531cce758d0eaa0e238bec745 100644
--- a/packages/CLI11/tests/OptionalTest.cpp
+++ b/packages/CLI11/tests/OptionalTest.cpp
@@ -62,70 +62,70 @@
#pragma warning(disable : 4244)
#endif
-TEST_F(TApp, StdOptionalTest) {
+TEST_CASE_METHOD(TApp, "StdOptionalTest", "[optional]") {
std::optional<int> opt;
app.add_option("-c,--count", opt);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 1);
+ CHECK(opt);
+ CHECK(1 == *opt);
args = {"--count", "3"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 3);
+ CHECK(opt);
+ CHECK(3 == *opt);
}
-TEST_F(TApp, StdOptionalVectorEmptyDirect) {
+TEST_CASE_METHOD(TApp, "StdOptionalVectorEmptyDirect", "[optional]") {
std::optional<std::vector<int>> opt;
app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
// app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v"};
opt = std::vector<int>{4, 3};
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v", "1", "4", "5"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::vector<int> expV{1, 4, 5};
- EXPECT_EQ(*opt, expV);
+ CHECK(expV == *opt);
}
-TEST_F(TApp, StdOptionalComplexDirect) {
+TEST_CASE_METHOD(TApp, "StdOptionalComplexDirect", "[optional]") {
std::optional<std::complex<double>> opt;
app.add_option("-c,--complex", opt)->type_size(0, 2);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c"};
opt = std::complex<double>{4.0, 3.0};
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1+2j"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::complex<double> val{1, 2};
- EXPECT_EQ(*opt, val);
+ CHECK(val == *opt);
args = {"-c", "3", "-4"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::complex<double> val2{3, -4};
- EXPECT_EQ(*opt, val2);
+ CHECK(val2 == *opt);
}
-TEST_F(TApp, StdOptionalUint) {
+TEST_CASE_METHOD(TApp, "StdOptionalUint", "[optional]") {
std::optional<std::uint64_t> opt;
app.add_option("-i,--int", opt);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-i", "15"};
run();
- EXPECT_EQ(*opt, 15U);
+ CHECK(15U == *opt);
static_assert(CLI::detail::classify_object<std::optional<std::uint64_t>>::value ==
CLI::detail::object_category::wrapper_value);
}
@@ -137,97 +137,97 @@ TEST_F(TApp, StdOptionalUint) {
#endif
#if CLI11_EXPERIMENTAL_OPTIONAL
-TEST_F(TApp, ExperimentalOptionalTest) {
+TEST_CASE_METHOD(TApp, "ExperimentalOptionalTest", "[optional]") {
std::experimental::optional<int> opt;
app.add_option("-c,--count", opt);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 1);
+ CHECK(opt);
+ CHECK(1 == *opt);
args = {"--count", "3"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 3);
+ CHECK(opt);
+ CHECK(3 == *opt);
}
#endif
#if CLI11_BOOST_OPTIONAL
-TEST_F(TApp, BoostOptionalTest) {
+TEST_CASE_METHOD(TApp, "BoostOptionalTest", "[optional]") {
boost::optional<int> opt;
app.add_option("-c,--count", opt);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 1);
+ CHECK(opt);
+ CHECK(1 == *opt);
opt = {};
args = {"--count", "3"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 3);
+ CHECK(opt);
+ CHECK(3 == *opt);
}
-TEST_F(TApp, BoostOptionalTestZarg) {
+TEST_CASE_METHOD(TApp, "BoostOptionalTestZarg", "[optional]") {
boost::optional<int> opt;
app.add_option("-c,--count", opt)->expected(0, 1);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 1);
+ CHECK(opt);
+ CHECK(1 == *opt);
opt = {};
args = {"--count"};
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
}
-TEST_F(TApp, BoostOptionalint64Test) {
+TEST_CASE_METHOD(TApp, "BoostOptionalint64Test", "[optional]") {
boost::optional<std::int64_t> opt;
app.add_option("-c,--count", opt);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 1);
+ CHECK(opt);
+ CHECK(1 == *opt);
opt = {};
args = {"--count", "3"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, 3);
+ CHECK(opt);
+ CHECK(3 == *opt);
}
-TEST_F(TApp, BoostOptionalStringTest) {
+TEST_CASE_METHOD(TApp, "BoostOptionalStringTest", "[optional]") {
boost::optional<std::string> opt;
app.add_option("-s,--string", opt);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-s", "strval"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, "strval");
+ CHECK(opt);
+ CHECK("strval" == *opt);
opt = {};
args = {"--string", "strv"};
run();
- EXPECT_TRUE(opt);
- EXPECT_EQ(*opt, "strv");
+ CHECK(opt);
+ CHECK("strv" == *opt);
}
namespace boost {
using CLI::enums::operator<<;
}
-TEST_F(TApp, BoostOptionalEnumTest) {
+TEST_CASE_METHOD(TApp, "BoostOptionalEnumTest", "[optional]") {
enum class eval : char { val0 = 0, val1 = 1, val2 = 2, val3 = 3, val4 = 4 };
boost::optional<eval> opt, opt2;
@@ -237,93 +237,89 @@ TEST_F(TApp, BoostOptionalEnumTest) {
optptr->capture_default_str();
auto dstring = optptr->get_default_str();
- EXPECT_TRUE(dstring.empty());
+ CHECK(dstring.empty());
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v", "3"};
run();
- EXPECT_TRUE(opt);
- EXPECT_TRUE(*opt == eval::val3);
+ CHECK(opt);
+ CHECK(*opt == eval::val3);
opt = {};
args = {"--val", "1"};
run();
- EXPECT_TRUE(opt);
- EXPECT_TRUE(*opt == eval::val1);
+ CHECK(opt);
+ CHECK(*opt == eval::val1);
}
-TEST_F(TApp, BoostOptionalVector) {
+TEST_CASE_METHOD(TApp, "BoostOptionalVector", "[optional]") {
boost::optional<std::vector<int>> opt;
app.add_option_function<std::vector<int>>(
"-v,--vec", [&opt](const std::vector<int> &v) { opt = v; }, "some vector")
->expected(3);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v", "1", "4", "5"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::vector<int> expV{1, 4, 5};
- EXPECT_EQ(*opt, expV);
+ CHECK(expV == *opt);
}
-TEST_F(TApp, BoostOptionalVectorEmpty) {
+TEST_CASE_METHOD(TApp, "BoostOptionalVectorEmpty", "[optional]") {
boost::optional<std::vector<int>> opt;
app.add_option<decltype(opt), std::vector<int>>("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
// app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v"};
opt = std::vector<int>{4, 3};
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v", "1", "4", "5"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::vector<int> expV{1, 4, 5};
- EXPECT_EQ(*opt, expV);
+ CHECK(expV == *opt);
}
-TEST_F(TApp, BoostOptionalVectorEmptyDirect) {
+TEST_CASE_METHOD(TApp, "BoostOptionalVectorEmptyDirect", "[optional]") {
boost::optional<std::vector<int>> opt;
app.add_option_no_stream("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
// app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v"};
opt = std::vector<int>{4, 3};
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-v", "1", "4", "5"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::vector<int> expV{1, 4, 5};
- EXPECT_EQ(*opt, expV);
+ CHECK(expV == *opt);
}
-TEST_F(TApp, BoostOptionalComplexDirect) {
+TEST_CASE_METHOD(TApp, "BoostOptionalComplexDirect", "[optional]") {
boost::optional<std::complex<double>> opt;
app.add_option("-c,--complex", opt)->type_size(0, 2);
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c"};
opt = std::complex<double>{4.0, 3.0};
run();
- EXPECT_FALSE(opt);
+ CHECK(!opt);
args = {"-c", "1+2j"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::complex<double> val{1, 2};
- EXPECT_EQ(*opt, val);
+ CHECK(val == *opt);
args = {"-c", "3", "-4"};
run();
- EXPECT_TRUE(opt);
+ CHECK(opt);
std::complex<double> val2{3, -4};
- EXPECT_EQ(*opt, val2);
+ CHECK(val2 == *opt);
}
#endif
-
-#if !CLI11_OPTIONAL
-TEST_F(TApp, DISABLED_OptionalTest) {}
-#endif
diff --git a/packages/CLI11/tests/SetTest.cpp b/packages/CLI11/tests/SetTest.cpp
index 7b6236edcbb13dfe0eab73200e11fd223daf57bf..d34a67a64f2163a7e1704fbc99a1952188611e37 100644
--- a/packages/CLI11/tests/SetTest.cpp
+++ b/packages/CLI11/tests/SetTest.cpp
@@ -31,79 +31,79 @@ static_assert(CLI::detail::pair_adaptor<std::vector<std::string>>::value == fals
static_assert(CLI::detail::pair_adaptor<std::map<int, int>>::value == true, "Should have pairs");
static_assert(CLI::detail::pair_adaptor<std::vector<std::pair<int, int>>>::value == true, "Should have pairs");
-TEST_F(TApp, SimpleMaps) {
+TEST_CASE_METHOD(TApp, "SimpleMaps", "[set]") {
int value{0};
std::map<std::string, int> map = {{"one", 1}, {"two", 2}};
auto opt = app.add_option("-s,--set", value)->transform(CLI::Transformer(map));
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
-TEST_F(TApp, StringStringMap) {
+TEST_CASE_METHOD(TApp, "StringStringMap", "[set]") {
std::string value;
std::map<std::string, std::string> map = {{"a", "b"}, {"b", "c"}};
app.add_option("-s,--set", value)->transform(CLI::CheckedTransformer(map));
args = {"-s", "a"};
run();
- EXPECT_EQ(value, "b");
+ CHECK("b" == value);
args = {"-s", "b"};
run();
- EXPECT_EQ(value, "c");
+ CHECK("c" == value);
args = {"-s", "c"};
- EXPECT_EQ(value, "c");
+ CHECK("c" == value);
}
-TEST_F(TApp, StringStringMapNoModify) {
+TEST_CASE_METHOD(TApp, "StringStringMapNoModify", "[set]") {
std::string value;
std::map<std::string, std::string> map = {{"a", "b"}, {"b", "c"}};
app.add_option("-s,--set", value)->check(CLI::IsMember(map));
args = {"-s", "a"};
run();
- EXPECT_EQ(value, "a");
+ CHECK("a" == value);
args = {"-s", "b"};
run();
- EXPECT_EQ(value, "b");
+ CHECK("b" == value);
args = {"-s", "c"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
enum SimpleEnum { SE_one = 1, SE_two = 2 };
-TEST_F(TApp, EnumMap) {
+TEST_CASE_METHOD(TApp, "EnumMap", "[set]") {
SimpleEnum value;
std::map<std::string, SimpleEnum> map = {{"one", SE_one}, {"two", SE_two}};
auto opt = app.add_option("-s,--set", value)->transform(CLI::Transformer(map));
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, SE_one);
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(SE_one == value);
}
enum class SimpleEnumC { one = 1, two = 2 };
-TEST_F(TApp, EnumCMap) {
+TEST_CASE_METHOD(TApp, "EnumCMap", "[set]") {
SimpleEnumC value;
std::map<std::string, SimpleEnumC> map = {{"one", SimpleEnumC::one}, {"two", SimpleEnumC::two}};
auto opt = app.add_option("-s,--set", value)->transform(CLI::Transformer(map));
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, SimpleEnumC::one);
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(SimpleEnumC::one == value);
}
-TEST_F(TApp, structMap) {
+TEST_CASE_METHOD(TApp, "structMap", "[set]") {
struct tstruct {
int val2;
double val3;
@@ -114,16 +114,16 @@ TEST_F(TApp, structMap) {
auto opt = app.add_option("-s,--set", struct_name)->check(CLI::IsMember(map));
args = {"-s", "sone"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(struct_name, "sone");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("sone" == struct_name);
args = {"-s", "sthree"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, structMapChange) {
+TEST_CASE_METHOD(TApp, "structMapChange", "[set]") {
struct tstruct {
int val2;
double val3;
@@ -135,23 +135,23 @@ TEST_F(TApp, structMapChange) {
->transform(CLI::IsMember(map, CLI::ignore_case, CLI::ignore_underscore, CLI::ignore_space));
args = {"-s", "s one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(struct_name, "sone");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("sone" == struct_name);
args = {"-s", "sthree"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-s", "S_t_w_o"};
run();
- EXPECT_EQ(struct_name, "stwo");
+ CHECK("stwo" == struct_name);
args = {"-s", "S two"};
run();
- EXPECT_EQ(struct_name, "stwo");
+ CHECK("stwo" == struct_name);
}
-TEST_F(TApp, structMapNoChange) {
+TEST_CASE_METHOD(TApp, "structMapNoChange", "[set]") {
struct tstruct {
int val2;
double val3;
@@ -163,24 +163,24 @@ TEST_F(TApp, structMapNoChange) {
->check(CLI::IsMember(map, CLI::ignore_case, CLI::ignore_underscore, CLI::ignore_space));
args = {"-s", "SONE"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(struct_name, "SONE");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("SONE" == struct_name);
args = {"-s", "sthree"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-s", "S_t_w_o"};
run();
- EXPECT_EQ(struct_name, "S_t_w_o");
+ CHECK("S_t_w_o" == struct_name);
args = {"-s", "S two"};
run();
- EXPECT_EQ(struct_name, "S two");
+ CHECK("S two" == struct_name);
}
-TEST_F(TApp, NonCopyableMap) {
+TEST_CASE_METHOD(TApp, "NonCopyableMap", "[set]") {
std::string map_name;
std::map<std::string, std::unique_ptr<double>> map;
@@ -189,16 +189,16 @@ TEST_F(TApp, NonCopyableMap) {
auto opt = app.add_option("-s,--set", map_name)->check(CLI::IsMember(&map));
args = {"-s", "e1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(map_name, "e1");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("e1" == map_name);
args = {"-s", "e45"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, NonCopyableMapWithFunction) {
+TEST_CASE_METHOD(TApp, "NonCopyableMapWithFunction", "[set]") {
std::string map_name;
std::map<std::string, std::unique_ptr<double>> map;
@@ -207,16 +207,16 @@ TEST_F(TApp, NonCopyableMapWithFunction) {
auto opt = app.add_option("-s,--set", map_name)->transform(CLI::IsMember(&map, CLI::ignore_underscore));
args = {"-s", "e_1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(map_name, "e1");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("e1" == map_name);
args = {"-s", "e45"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, NonCopyableMapNonStringMap) {
+TEST_CASE_METHOD(TApp, "NonCopyableMapNonStringMap", "[set]") {
std::string map_name;
std::map<int, std::unique_ptr<double>> map;
@@ -225,16 +225,16 @@ TEST_F(TApp, NonCopyableMapNonStringMap) {
auto opt = app.add_option("-s,--set", map_name)->check(CLI::IsMember(&map));
args = {"-s", "4"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(map_name, "4");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("4" == map_name);
args = {"-s", "e45"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, CopyableMapMove) {
+TEST_CASE_METHOD(TApp, "CopyableMapMove", "[set]") {
std::string map_name;
std::map<int, double> map;
@@ -243,162 +243,162 @@ TEST_F(TApp, CopyableMapMove) {
auto opt = app.add_option("-s,--set", map_name)->check(CLI::IsMember(std::move(map)));
args = {"-s", "4"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(map_name, "4");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("4" == map_name);
args = {"-s", "e45"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, SimpleSets) {
+TEST_CASE_METHOD(TApp, "SimpleSets", "[set]") {
std::string value;
auto opt = app.add_option("-s,--set", value)->check(CLI::IsMember{std::set<std::string>({"one", "two", "three"})});
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, "one");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("one" == value);
}
-TEST_F(TApp, SimpleSetsPtrs) {
+TEST_CASE_METHOD(TApp, "SimpleSetsPtrs", "[set]") {
auto set = std::shared_ptr<std::set<std::string>>(new std::set<std::string>{"one", "two", "three"});
std::string value;
auto opt = app.add_option("-s,--set", value)->check(CLI::IsMember{set});
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, "one");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("one" == value);
set->insert("four");
args = {"-s", "four"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, "four");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("four" == value);
}
-TEST_F(TApp, SimiShortcutSets) {
+TEST_CASE_METHOD(TApp, "SimiShortcutSets", "[set]") {
std::string value;
auto opt = app.add_option("--set", value)->check(CLI::IsMember({"one", "two", "three"}));
args = {"--set", "one"};
run();
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, "one");
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("one" == value);
std::string value2;
auto opt2 = app.add_option("--set2", value2)->transform(CLI::IsMember({"One", "two", "three"}, CLI::ignore_case));
args = {"--set2", "onE"};
run();
- EXPECT_EQ(1u, app.count("--set2"));
- EXPECT_EQ(1u, opt2->count());
- EXPECT_EQ(value2, "One");
+ CHECK(app.count("--set2") == 1u);
+ CHECK(opt2->count() == 1u);
+ CHECK("One" == value2);
std::string value3;
auto opt3 = app.add_option("--set3", value3)
->transform(CLI::IsMember({"O_ne", "two", "three"}, CLI::ignore_case, CLI::ignore_underscore));
args = {"--set3", "onE"};
run();
- EXPECT_EQ(1u, app.count("--set3"));
- EXPECT_EQ(1u, opt3->count());
- EXPECT_EQ(value3, "O_ne");
+ CHECK(app.count("--set3") == 1u);
+ CHECK(opt3->count() == 1u);
+ CHECK("O_ne" == value3);
}
-TEST_F(TApp, SetFromCharStarArrayVector) {
+TEST_CASE_METHOD(TApp, "SetFromCharStarArrayVector", "[set]") {
constexpr const char *names[3]{"one", "two", "three"};
std::string value;
auto opt = app.add_option("-s,--set", value)
->check(CLI::IsMember{std::vector<std::string>(std::begin(names), std::end(names))});
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, "one");
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK("one" == value);
}
-TEST_F(TApp, OtherTypeSets) {
+TEST_CASE_METHOD(TApp, "OtherTypeSets", "[set]") {
int value{0};
std::vector<int> set = {2, 3, 4};
auto opt = app.add_option("--set", value)->check(CLI::IsMember(set));
args = {"--set", "3"};
run();
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 3);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(3 == value);
args = {"--set", "5"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
std::vector<int> set2 = {-2, 3, 4};
auto opt2 = app.add_option("--set2", value)->transform(CLI::IsMember(set2, [](int x) { return std::abs(x); }));
args = {"--set2", "-3"};
run();
- EXPECT_EQ(1u, app.count("--set2"));
- EXPECT_EQ(1u, opt2->count());
- EXPECT_EQ(value, 3);
+ CHECK(app.count("--set2") == 1u);
+ CHECK(opt2->count() == 1u);
+ CHECK(3 == value);
args = {"--set2", "-3"};
run();
- EXPECT_EQ(1u, app.count("--set2"));
- EXPECT_EQ(1u, opt2->count());
- EXPECT_EQ(value, 3);
+ CHECK(app.count("--set2") == 1u);
+ CHECK(opt2->count() == 1u);
+ CHECK(3 == value);
args = {"--set2", "2"};
run();
- EXPECT_EQ(1u, app.count("--set2"));
- EXPECT_EQ(1u, opt2->count());
- EXPECT_EQ(value, -2);
+ CHECK(app.count("--set2") == 1u);
+ CHECK(opt2->count() == 1u);
+ CHECK(-2 == value);
}
-TEST_F(TApp, NumericalSets) {
+TEST_CASE_METHOD(TApp, "NumericalSets", "[set]") {
int value{0};
auto opt = app.add_option("-s,--set", value)->check(CLI::IsMember{std::set<int>({1, 2, 3})});
args = {"-s", "1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, app.count("--set"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(app.count("--set") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
// Converted original set tests
-TEST_F(TApp, SetWithDefaults) {
+TEST_CASE_METHOD(TApp, "SetWithDefaults", "[set]") {
int someint{2};
app.add_option("-a", someint, "", true)->check(CLI::IsMember({1, 2, 3, 4}));
args = {"-a1", "-a2"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, SetWithDefaultsConversion) {
+TEST_CASE_METHOD(TApp, "SetWithDefaultsConversion", "[set]") {
int someint{2};
app.add_option("-a", someint, "", true)->check(CLI::IsMember({1, 2, 3, 4}));
args = {"-a", "hi"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, SetWithDefaultsIC) {
+TEST_CASE_METHOD(TApp, "SetWithDefaultsIC", "[set]") {
std::string someint = "ho";
app.add_option("-a", someint, "", true)->check(CLI::IsMember({"Hi", "Ho"}));
args = {"-aHi", "-aHo"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, InSet) {
+TEST_CASE_METHOD(TApp, "InSet", "[set]") {
std::string choice;
app.add_option("-q,--quick", choice)->check(CLI::IsMember({"one", "two", "three"}));
@@ -406,47 +406,47 @@ TEST_F(TApp, InSet) {
args = {"--quick", "two"};
run();
- EXPECT_EQ("two", choice);
+ CHECK(choice == "two");
args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, InSetWithDefault) {
+TEST_CASE_METHOD(TApp, "InSetWithDefault", "[set]") {
std::string choice = "one";
app.add_option("-q,--quick", choice, "", true)->check(CLI::IsMember({"one", "two", "three"}));
run();
- EXPECT_EQ("one", choice);
+ CHECK(choice == "one");
args = {"--quick", "two"};
run();
- EXPECT_EQ("two", choice);
+ CHECK(choice == "two");
args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, InCaselessSetWithDefault) {
+TEST_CASE_METHOD(TApp, "InCaselessSetWithDefault", "[set]") {
std::string choice = "one";
app.add_option("-q,--quick", choice, "", true)->transform(CLI::IsMember({"one", "two", "three"}, CLI::ignore_case));
run();
- EXPECT_EQ("one", choice);
+ CHECK(choice == "one");
args = {"--quick", "tWo"};
run();
- EXPECT_EQ("two", choice);
+ CHECK(choice == "two");
args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, InIntSet) {
+TEST_CASE_METHOD(TApp, "InIntSet", "[set]") {
int choice{0};
app.add_option("-q,--quick", choice)->check(CLI::IsMember({1, 2, 3}));
@@ -454,13 +454,13 @@ TEST_F(TApp, InIntSet) {
args = {"--quick", "2"};
run();
- EXPECT_EQ(2, choice);
+ CHECK(choice == 2);
args = {"--quick", "4"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, InIntSetWindows) {
+TEST_CASE_METHOD(TApp, "InIntSetWindows", "[set]") {
int choice{0};
app.add_option("-q,--quick", choice)->check(CLI::IsMember({1, 2, 3}));
@@ -468,28 +468,28 @@ TEST_F(TApp, InIntSetWindows) {
args = {"/q", "2"};
run();
- EXPECT_EQ(2, choice);
+ CHECK(choice == 2);
args = {"/q", "4"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"/q4"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, FailSet) {
+TEST_CASE_METHOD(TApp, "FailSet", "[set]") {
int choice{0};
app.add_option("-q,--quick", choice)->check(CLI::IsMember({1, 2, 3}));
args = {"--quick", "3", "--quick=2"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
args = {"--quick=hello"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, FailMutableSet) {
+TEST_CASE_METHOD(TApp, "FailMutableSet", "[set]") {
int choice{0};
auto vals = std::shared_ptr<std::set<int>>(new std::set<int>({1, 2, 3}));
@@ -497,37 +497,37 @@ TEST_F(TApp, FailMutableSet) {
app.add_option("-s,--slow", choice, "", true)->check(CLI::IsMember(vals));
args = {"--quick=hello"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--slow=hello"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, InSetIgnoreCase) {
+TEST_CASE_METHOD(TApp, "InSetIgnoreCase", "[set]") {
std::string choice;
app.add_option("-q,--quick", choice)->transform(CLI::IsMember({"one", "Two", "THREE"}, CLI::ignore_case));
args = {"--quick", "One"};
run();
- EXPECT_EQ("one", choice);
+ CHECK(choice == "one");
args = {"--quick", "two"};
run();
- EXPECT_EQ("Two", choice); // Keeps caps from set
+ CHECK(choice == "Two");
args = {"--quick", "ThrEE"};
run();
- EXPECT_EQ("THREE", choice); // Keeps caps from set
+ CHECK(choice == "THREE");
args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--quick=one", "--quick=two"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, InSetIgnoreCaseMutableValue) {
+TEST_CASE_METHOD(TApp, "InSetIgnoreCaseMutableValue", "[set]") {
std::set<std::string> options{"one", "Two", "THREE"};
std::string choice;
@@ -535,22 +535,22 @@ TEST_F(TApp, InSetIgnoreCaseMutableValue) {
args = {"--quick", "One"};
run();
- EXPECT_EQ("one", choice);
+ CHECK(choice == "one");
args = {"--quick", "two"};
run();
- EXPECT_EQ("Two", choice); // Keeps caps from set
+ CHECK(choice == "Two");
args = {"--quick", "ThrEE"};
run();
- EXPECT_EQ("THREE", choice); // Keeps caps from set
+ CHECK(choice == "THREE");
options.clear();
args = {"--quick", "ThrEE"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, InSetIgnoreCasePointer) {
+TEST_CASE_METHOD(TApp, "InSetIgnoreCasePointer", "[set]") {
std::set<std::string> *options = new std::set<std::string>{"one", "Two", "THREE"};
std::string choice;
@@ -558,43 +558,43 @@ TEST_F(TApp, InSetIgnoreCasePointer) {
args = {"--quick", "One"};
run();
- EXPECT_EQ("one", choice);
+ CHECK(choice == "one");
args = {"--quick", "two"};
run();
- EXPECT_EQ("Two", choice); // Keeps caps from set
+ CHECK(choice == "Two");
args = {"--quick", "ThrEE"};
run();
- EXPECT_EQ("THREE", choice); // Keeps caps from set
+ CHECK(choice == "THREE");
delete options;
args = {"--quick", "ThrEE"};
run();
- EXPECT_EQ("THREE", choice); // this does not throw a segfault
+ CHECK(choice == "THREE");
args = {"--quick", "four"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--quick=one", "--quick=two"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, NotInSetIgnoreCasePointer) {
+TEST_CASE_METHOD(TApp, "NotInSetIgnoreCasePointer", "[set]") {
std::set<std::string> *options = new std::set<std::string>{"one", "Two", "THREE"};
std::string choice;
app.add_option("-q,--quick", choice)->check(!CLI::IsMember(*options, CLI::ignore_case));
args = {"--quick", "One"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--quick", "four"};
run();
- EXPECT_EQ(choice, "four");
+ CHECK("four" == choice);
}
-TEST_F(TApp, InSetIgnoreUnderscore) {
+TEST_CASE_METHOD(TApp, "InSetIgnoreUnderscore", "[set]") {
std::string choice;
app.add_option("-q,--quick", choice)
@@ -602,24 +602,24 @@ TEST_F(TApp, InSetIgnoreUnderscore) {
args = {"--quick", "option_one"};
run();
- EXPECT_EQ("option_one", choice);
+ CHECK(choice == "option_one");
args = {"--quick", "optiontwo"};
run();
- EXPECT_EQ("option_two", choice); // Keeps underscore from set
+ CHECK(choice == "option_two");
args = {"--quick", "_option_thr_ee"};
run();
- EXPECT_EQ("optionthree", choice); // no underscore
+ CHECK(choice == "optionthree");
args = {"--quick", "Option4"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--quick=option_one", "--quick=option_two"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
-TEST_F(TApp, InSetIgnoreCaseUnderscore) {
+TEST_CASE_METHOD(TApp, "InSetIgnoreCaseUnderscore", "[set]") {
std::string choice;
app.add_option("-q,--quick", choice)
@@ -628,25 +628,25 @@ TEST_F(TApp, InSetIgnoreCaseUnderscore) {
args = {"--quick", "option_one"};
run();
- EXPECT_EQ("Option_One", choice);
+ CHECK(choice == "Option_One");
args = {"--quick", "OptionTwo"};
run();
- EXPECT_EQ("option_two", choice); // Keeps underscore and case from set
+ CHECK(choice == "option_two");
args = {"--quick", "_OPTION_thr_ee"};
run();
- EXPECT_EQ("OptionThree", choice); // no underscore
+ CHECK(choice == "OptionThree");
args = {"--quick", "Option4"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--quick=option_one", "--quick=option_two"};
- EXPECT_THROW(run(), CLI::ArgumentMismatch);
+ CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
}
// #113
-TEST_F(TApp, AddRemoveSetItems) {
+TEST_CASE_METHOD(TApp, "AddRemoveSetItems", "[set]") {
std::set<std::string> items{"TYPE1", "TYPE2", "TYPE3", "TYPE4", "TYPE5"};
std::string type1, type2;
@@ -656,8 +656,8 @@ TEST_F(TApp, AddRemoveSetItems) {
args = {"--type1", "TYPE1", "--type2", "TYPE2"};
run();
- EXPECT_EQ(type1, "TYPE1");
- EXPECT_EQ(type2, "TYPE2");
+ CHECK("TYPE1" == type1);
+ CHECK("TYPE2" == type2);
items.insert("TYPE6");
items.insert("TYPE7");
@@ -667,17 +667,17 @@ TEST_F(TApp, AddRemoveSetItems) {
args = {"--type1", "TYPE6", "--type2", "TYPE7"};
run();
- EXPECT_EQ(type1, "TYPE6");
- EXPECT_EQ(type2, "TYPE7");
+ CHECK("TYPE6" == type1);
+ CHECK("TYPE7" == type2);
args = {"--type1", "TYPE1"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--type2", "TYPE2"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, AddRemoveSetItemsNoCase) {
+TEST_CASE_METHOD(TApp, "AddRemoveSetItemsNoCase", "[set]") {
std::set<std::string> items{"TYPE1", "TYPE2", "TYPE3", "TYPE4", "TYPE5"};
std::string type1, type2;
@@ -687,8 +687,8 @@ TEST_F(TApp, AddRemoveSetItemsNoCase) {
args = {"--type1", "TYPe1", "--type2", "TyPE2"};
run();
- EXPECT_EQ(type1, "TYPE1");
- EXPECT_EQ(type2, "TYPE2");
+ CHECK("TYPE1" == type1);
+ CHECK("TYPE2" == type2);
items.insert("TYPE6");
items.insert("TYPE7");
@@ -698,12 +698,12 @@ TEST_F(TApp, AddRemoveSetItemsNoCase) {
args = {"--type1", "TyPE6", "--type2", "tYPE7"};
run();
- EXPECT_EQ(type1, "TYPE6");
- EXPECT_EQ(type2, "TYPE7");
+ CHECK("TYPE6" == type1);
+ CHECK("TYPE7" == type2);
args = {"--type1", "TYPe1"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"--type2", "TYpE2"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
diff --git a/packages/CLI11/tests/SimpleTest.cpp b/packages/CLI11/tests/SimpleTest.cpp
index dfcd5579127bf363a04893de6826fbb36ed345bd..92262b5e64ef7f30a65fe50d7a38592d33ac1809 100644
--- a/packages/CLI11/tests/SimpleTest.cpp
+++ b/packages/CLI11/tests/SimpleTest.cpp
@@ -10,11 +10,11 @@
#include "CLI/CLI.hpp"
#endif
-#include "gtest/gtest.h"
+#include "catch.hpp"
using input_t = std::vector<std::string>;
-TEST(Basic, Empty) {
+TEST_CASE("Basic: Empty", "[simple]") {
{
CLI::App app;
@@ -24,7 +24,7 @@ TEST(Basic, Empty) {
{
CLI::App app;
input_t spare = {"spare"};
- EXPECT_THROW(app.parse(spare), CLI::ExtrasError);
+ CHECK_THROWS_AS(app.parse(spare), CLI::ExtrasError);
}
{
CLI::App app;
diff --git a/packages/CLI11/tests/StringParseTest.cpp b/packages/CLI11/tests/StringParseTest.cpp
index 568bb4ecc45105db27fd51df415c70c379016cac..3a9f7371d87bd0412554eb49d2fe559ea060c95c 100644
--- a/packages/CLI11/tests/StringParseTest.cpp
+++ b/packages/CLI11/tests/StringParseTest.cpp
@@ -6,11 +6,10 @@
#include "app_helper.hpp"
-#include "gmock/gmock.h"
#include <cstdio>
#include <sstream>
-TEST_F(TApp, ExistingExeCheck) {
+TEST_CASE_METHOD(TApp, "ExistingExeCheck", "[stringparse]") {
TempFile tmpexe{"existingExe.out"};
@@ -27,12 +26,12 @@ TEST_F(TApp, ExistingExeCheck) {
app.parse(std::string("./") + std::string(tmpexe) +
" --string=\"this is my quoted string\" -t 'qstring 2' -m=`\"quoted string\"`",
true);
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
}
-TEST_F(TApp, ExistingExeCheckWithSpace) {
+TEST_CASE_METHOD(TApp, "ExistingExeCheckWithSpace", "[stringparse]") {
TempFile tmpexe{"Space File.out"};
@@ -49,14 +48,14 @@ TEST_F(TApp, ExistingExeCheckWithSpace) {
app.parse(std::string("./") + std::string(tmpexe) +
" --string=\"this is my quoted string\" -t 'qstring 2' -m=`\"quoted string\"`",
true);
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
- EXPECT_EQ(app.get_name(), std::string("./") + std::string(tmpexe));
+ CHECK(std::string("./") + std::string(tmpexe) == app.get_name());
}
-TEST_F(TApp, ExistingExeCheckWithLotsOfSpace) {
+TEST_CASE_METHOD(TApp, "ExistingExeCheckWithLotsOfSpace", "[stringparse]") {
TempFile tmpexe{"this is a weird file.exe"};
@@ -73,9 +72,9 @@ TEST_F(TApp, ExistingExeCheckWithLotsOfSpace) {
app.parse(std::string("./") + std::string(tmpexe) +
" --string=\"this is my quoted string\" -t 'qstring 2' -m=`\"quoted string\"`",
true);
- EXPECT_EQ(str, "this is my quoted string");
- EXPECT_EQ(str2, "qstring 2");
- EXPECT_EQ(str3, "\"quoted string\"");
+ CHECK("this is my quoted string" == str);
+ CHECK("qstring 2" == str2);
+ CHECK("\"quoted string\"" == str3);
- EXPECT_EQ(app.get_name(), std::string("./") + std::string(tmpexe));
+ CHECK(std::string("./") + std::string(tmpexe) == app.get_name());
}
diff --git a/packages/CLI11/tests/SubcommandTest.cpp b/packages/CLI11/tests/SubcommandTest.cpp
index e6f961345ed1f784f9bb0a02a02899b8a9c4ec1d..eef67bca7d44994678b3534dd8c3d155171a7479 100644
--- a/packages/CLI11/tests/SubcommandTest.cpp
+++ b/packages/CLI11/tests/SubcommandTest.cpp
@@ -6,59 +6,55 @@
#include "app_helper.hpp"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-using ::testing::HasSubstr;
-using ::testing::Not;
+using Catch::Matchers::Contains;
using vs_t = std::vector<std::string>;
-TEST_F(TApp, BasicSubcommands) {
+TEST_CASE_METHOD(TApp, "BasicSubcommands", "[subcom]") {
auto sub1 = app.add_subcommand("sub1");
auto sub2 = app.add_subcommand("sub2");
- EXPECT_EQ(sub1->get_parent(), &app);
+ CHECK(&app == sub1->get_parent());
- EXPECT_EQ(sub1, app.get_subcommand(sub1));
- EXPECT_EQ(sub1, app.get_subcommand("sub1"));
- EXPECT_THROW(app.get_subcommand("sub3"), CLI::OptionNotFound);
+ CHECK(app.get_subcommand(sub1) == sub1);
+ CHECK(app.get_subcommand("sub1") == sub1);
+ CHECK_THROWS_AS(app.get_subcommand("sub3"), CLI::OptionNotFound);
run();
- EXPECT_EQ(0u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().size() == 0u);
args = {"sub1"};
run();
- EXPECT_EQ(sub1, app.get_subcommands().at(0));
- EXPECT_EQ(1u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().at(0) == sub1);
+ CHECK(app.get_subcommands().size() == 1u);
app.clear();
- EXPECT_EQ(0u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().size() == 0u);
args = {"sub2"};
run();
- EXPECT_EQ(1u, app.get_subcommands().size());
- EXPECT_EQ(sub2, app.get_subcommands().at(0));
+ CHECK(app.get_subcommands().size() == 1u);
+ CHECK(app.get_subcommands().at(0) == sub2);
args = {"SUb2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"SUb2"};
try {
run();
} catch(const CLI::ExtrasError &e) {
- EXPECT_THAT(e.what(), HasSubstr("SUb2"));
+ CHECK_THAT(e.what(), Contains("SUb2"));
}
args = {"sub1", "extra"};
try {
run();
} catch(const CLI::ExtrasError &e) {
- EXPECT_THAT(e.what(), HasSubstr("extra"));
+ CHECK_THAT(e.what(), Contains("extra"));
}
}
-TEST_F(TApp, MultiSubFallthrough) {
+TEST_CASE_METHOD(TApp, "MultiSubFallthrough", "[subcom]") {
// No explicit fallthrough
auto sub1 = app.add_subcommand("sub1");
@@ -66,15 +62,15 @@ TEST_F(TApp, MultiSubFallthrough) {
args = {"sub1", "sub2"};
run();
- EXPECT_TRUE(app.got_subcommand("sub1"));
- EXPECT_TRUE(app.got_subcommand(sub1));
- EXPECT_TRUE(*sub1);
- EXPECT_TRUE(sub1->parsed());
- EXPECT_EQ(sub1->count(), 1u);
+ CHECK(app.got_subcommand("sub1"));
+ CHECK(app.got_subcommand(sub1));
+ CHECK(*sub1);
+ CHECK(sub1->parsed());
+ CHECK(1u == sub1->count());
- EXPECT_TRUE(app.got_subcommand("sub2"));
- EXPECT_TRUE(app.got_subcommand(sub2));
- EXPECT_TRUE(*sub2);
+ CHECK(app.got_subcommand("sub2"));
+ CHECK(app.got_subcommand(sub2));
+ CHECK(*sub2);
app.require_subcommand();
run();
@@ -83,34 +79,34 @@ TEST_F(TApp, MultiSubFallthrough) {
run();
app.require_subcommand(1);
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"sub1"};
run();
- EXPECT_TRUE(app.got_subcommand("sub1"));
- EXPECT_FALSE(app.got_subcommand("sub2"));
+ CHECK(app.got_subcommand("sub1"));
+ CHECK(!app.got_subcommand("sub2"));
- EXPECT_TRUE(*sub1);
- EXPECT_FALSE(*sub2);
- EXPECT_FALSE(sub2->parsed());
- EXPECT_EQ(sub2->count(), 0u);
+ CHECK(*sub1);
+ CHECK(!*sub2);
+ CHECK(!sub2->parsed());
+ CHECK(0u == sub2->count());
- EXPECT_THROW(app.got_subcommand("sub3"), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app.got_subcommand("sub3"), CLI::OptionNotFound);
}
-TEST_F(TApp, CrazyNameSubcommand) {
+TEST_CASE_METHOD(TApp, "CrazyNameSubcommand", "[subcom]") {
auto sub1 = app.add_subcommand("sub1");
// name can be set to whatever
- EXPECT_NO_THROW(sub1->name("crazy name with spaces"));
+ CHECK_NOTHROW(sub1->name("crazy name with spaces"));
args = {"crazy name with spaces"};
run();
- EXPECT_TRUE(app.got_subcommand("crazy name with spaces"));
- EXPECT_EQ(sub1->count(), 1u);
+ CHECK(app.got_subcommand("crazy name with spaces"));
+ CHECK(1u == sub1->count());
}
-TEST_F(TApp, RequiredAndSubcommands) { // #23
+TEST_CASE_METHOD(TApp, "RequiredAndSubcommands", "[subcom]") {
std::string baz;
app.add_option("baz", baz, "Baz Description", true)->required();
@@ -118,26 +114,26 @@ TEST_F(TApp, RequiredAndSubcommands) { // #23
auto bar = app.add_subcommand("bar");
args = {"bar", "foo"};
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(*foo);
- EXPECT_FALSE(*bar);
- EXPECT_EQ(baz, "bar");
+ REQUIRE_NOTHROW(run());
+ CHECK(*foo);
+ CHECK(!*bar);
+ CHECK("bar" == baz);
args = {"foo"};
- ASSERT_NO_THROW(run());
- EXPECT_FALSE(*foo);
- EXPECT_EQ(baz, "foo");
+ REQUIRE_NOTHROW(run());
+ CHECK(!*foo);
+ CHECK("foo" == baz);
args = {"foo", "foo"};
- ASSERT_NO_THROW(run());
- EXPECT_TRUE(*foo);
- EXPECT_EQ(baz, "foo");
+ REQUIRE_NOTHROW(run());
+ CHECK(*foo);
+ CHECK("foo" == baz);
args = {"foo", "other"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, RequiredAndSubcomFallthrough) {
+TEST_CASE_METHOD(TApp, "RequiredAndSubcomFallthrough", "[subcom]") {
std::string baz;
app.add_option("baz", baz)->required();
@@ -147,14 +143,14 @@ TEST_F(TApp, RequiredAndSubcomFallthrough) {
args = {"other", "bar"};
run();
- EXPECT_TRUE(bar);
- EXPECT_EQ(baz, "other");
+ CHECK(bar);
+ CHECK("other" == baz);
args = {"bar", "other2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, FooFooProblem) {
+TEST_CASE_METHOD(TApp, "FooFooProblem", "[subcom]") {
std::string baz_str, other_str;
auto baz = app.add_option("baz", baz_str);
@@ -163,55 +159,55 @@ TEST_F(TApp, FooFooProblem) {
args = {"foo", "foo"};
run();
- EXPECT_TRUE(*foo);
- EXPECT_FALSE(*baz);
- EXPECT_TRUE(*other);
- EXPECT_EQ(baz_str, "");
- EXPECT_EQ(other_str, "foo");
+ CHECK(*foo);
+ CHECK(!*baz);
+ CHECK(*other);
+ CHECK("" == baz_str);
+ CHECK("foo" == other_str);
baz_str = "";
other_str = "";
baz->required();
run();
- EXPECT_TRUE(*foo);
- EXPECT_TRUE(*baz);
- EXPECT_FALSE(*other);
- EXPECT_EQ(baz_str, "foo");
- EXPECT_EQ(other_str, "");
+ CHECK(*foo);
+ CHECK(*baz);
+ CHECK(!*other);
+ CHECK("foo" == baz_str);
+ CHECK("" == other_str);
}
-TEST_F(TApp, DuplicateSubcommands) {
+TEST_CASE_METHOD(TApp, "DuplicateSubcommands", "[subcom]") {
auto foo = app.add_subcommand("foo");
args = {"foo", "foo"};
run();
- EXPECT_TRUE(*foo);
- EXPECT_EQ(foo->count(), 2u);
+ CHECK(*foo);
+ CHECK(2u == foo->count());
args = {"foo", "foo", "foo"};
run();
- EXPECT_TRUE(*foo);
- EXPECT_EQ(foo->count(), 3u);
+ CHECK(*foo);
+ CHECK(3u == foo->count());
}
-TEST_F(TApp, DuplicateSubcommandCallbacks) {
+TEST_CASE_METHOD(TApp, "DuplicateSubcommandCallbacks", "[subcom]") {
auto foo = app.add_subcommand("foo");
int count{0};
foo->callback([&count]() { ++count; });
foo->immediate_callback();
- EXPECT_TRUE(foo->get_immediate_callback());
+ CHECK(foo->get_immediate_callback());
args = {"foo", "foo"};
run();
- EXPECT_EQ(count, 2);
+ CHECK(2 == count);
count = 0;
args = {"foo", "foo", "foo"};
run();
- EXPECT_EQ(count, 3);
+ CHECK(3 == count);
}
-TEST_F(TApp, DuplicateSubcommandCallbacksValues) {
+TEST_CASE_METHOD(TApp, "DuplicateSubcommandCallbacksValues", "[subcom]") {
auto foo = app.add_subcommand("foo");
int val{0};
@@ -221,19 +217,19 @@ TEST_F(TApp, DuplicateSubcommandCallbacksValues) {
foo->immediate_callback();
args = {"foo", "--val=45", "foo", "--val=27"};
run();
- EXPECT_EQ(vals.size(), 2u);
- EXPECT_EQ(vals[0], 45);
- EXPECT_EQ(vals[1], 27);
+ CHECK(2u == vals.size());
+ CHECK(45 == vals[0]);
+ CHECK(27 == vals[1]);
vals.clear();
args = {"foo", "--val=45", "foo", "--val=27", "foo", "--val=36"};
run();
- EXPECT_EQ(vals.size(), 3u);
- EXPECT_EQ(vals[0], 45);
- EXPECT_EQ(vals[1], 27);
- EXPECT_EQ(vals[2], 36);
+ CHECK(3u == vals.size());
+ CHECK(45 == vals[0]);
+ CHECK(27 == vals[1]);
+ CHECK(36 == vals[2]);
}
-TEST_F(TApp, Callbacks) {
+TEST_CASE_METHOD(TApp, "Callbacks", "[subcom]") {
auto sub1 = app.add_subcommand("sub1");
sub1->callback([]() { throw CLI::Success(); });
auto sub2 = app.add_subcommand("sub2");
@@ -241,12 +237,12 @@ TEST_F(TApp, Callbacks) {
sub2->callback([&val]() { val = true; });
args = {"sub2"};
- EXPECT_FALSE(val);
+ CHECK(!val);
run();
- EXPECT_TRUE(val);
+ CHECK(val);
}
-TEST_F(TApp, CallbackOrder) {
+TEST_CASE_METHOD(TApp, "CallbackOrder", "[subcom]") {
std::vector<std::string> cb;
app.parse_complete_callback([&cb]() { cb.push_back("ac1"); });
@@ -281,18 +277,18 @@ TEST_F(TApp, CallbackOrder) {
"--sub2opt2",
"val"};
run();
- EXPECT_EQ(cb.size(), 8u);
- EXPECT_EQ(cb[0], "pa-13");
- EXPECT_EQ(cb[1], "pc1-10");
- EXPECT_EQ(cb[2], "c1");
- EXPECT_EQ(cb[3], "pc2-6");
- EXPECT_EQ(cb[4], "c1");
- EXPECT_EQ(cb[5], "ac1");
- EXPECT_EQ(cb[6], "c2");
- EXPECT_EQ(cb[7], "ac2");
+ CHECK(8u == cb.size());
+ CHECK("pa-13" == cb[0]);
+ CHECK("pc1-10" == cb[1]);
+ CHECK("c1" == cb[2]);
+ CHECK("pc2-6" == cb[3]);
+ CHECK("c1" == cb[4]);
+ CHECK("ac1" == cb[5]);
+ CHECK("c2" == cb[6]);
+ CHECK("ac2" == cb[7]);
}
-TEST_F(TApp, CallbackOrder2) {
+TEST_CASE_METHOD(TApp, "CallbackOrder2", "[subcom]") {
std::vector<std::string> cb;
app.add_subcommand("sub1")->parse_complete_callback([&cb]() { cb.push_back("sub1"); });
@@ -301,17 +297,17 @@ TEST_F(TApp, CallbackOrder2) {
args = {"sub1", "sub2", "sub3", "sub1", "sub1", "sub2", "sub1"};
run();
- EXPECT_EQ(cb.size(), 7u);
- EXPECT_EQ(cb[0], "sub1");
- EXPECT_EQ(cb[1], "sub2");
- EXPECT_EQ(cb[2], "sub3");
- EXPECT_EQ(cb[3], "sub1");
- EXPECT_EQ(cb[4], "sub1");
- EXPECT_EQ(cb[5], "sub2");
- EXPECT_EQ(cb[6], "sub1");
+ CHECK(7u == cb.size());
+ CHECK("sub1" == cb[0]);
+ CHECK("sub2" == cb[1]);
+ CHECK("sub3" == cb[2]);
+ CHECK("sub1" == cb[3]);
+ CHECK("sub1" == cb[4]);
+ CHECK("sub2" == cb[5]);
+ CHECK("sub1" == cb[6]);
}
-TEST_F(TApp, CallbackOrder2_withFallthrough) {
+TEST_CASE_METHOD(TApp, "CallbackOrder2_withFallthrough", "[subcom]") {
std::vector<std::string> cb;
@@ -321,64 +317,64 @@ TEST_F(TApp, CallbackOrder2_withFallthrough) {
args = {"sub1", "sub2", "sub3", "sub1", "sub1", "sub2", "sub1"};
run();
- EXPECT_EQ(cb.size(), 7u);
- EXPECT_EQ(cb[0], "sub1");
- EXPECT_EQ(cb[1], "sub2");
- EXPECT_EQ(cb[2], "sub3");
- EXPECT_EQ(cb[3], "sub1");
- EXPECT_EQ(cb[4], "sub1");
- EXPECT_EQ(cb[5], "sub2");
- EXPECT_EQ(cb[6], "sub1");
+ CHECK(7u == cb.size());
+ CHECK("sub1" == cb[0]);
+ CHECK("sub2" == cb[1]);
+ CHECK("sub3" == cb[2]);
+ CHECK("sub1" == cb[3]);
+ CHECK("sub1" == cb[4]);
+ CHECK("sub2" == cb[5]);
+ CHECK("sub1" == cb[6]);
}
-TEST_F(TApp, RuntimeErrorInCallback) {
+TEST_CASE_METHOD(TApp, "RuntimeErrorInCallback", "[subcom]") {
auto sub1 = app.add_subcommand("sub1");
sub1->callback([]() { throw CLI::RuntimeError(); });
auto sub2 = app.add_subcommand("sub2");
sub2->callback([]() { throw CLI::RuntimeError(2); });
args = {"sub1"};
- EXPECT_THROW(run(), CLI::RuntimeError);
+ CHECK_THROWS_AS(run(), CLI::RuntimeError);
args = {"sub1"};
try {
run();
} catch(const CLI::RuntimeError &e) {
- EXPECT_EQ(1, e.get_exit_code());
+ CHECK(e.get_exit_code() == 1);
}
args = {"sub2"};
- EXPECT_THROW(run(), CLI::RuntimeError);
+ CHECK_THROWS_AS(run(), CLI::RuntimeError);
args = {"sub2"};
try {
run();
} catch(const CLI::RuntimeError &e) {
- EXPECT_EQ(2, e.get_exit_code());
+ CHECK(e.get_exit_code() == 2);
}
}
-TEST_F(TApp, NoFallThroughOpts) {
+TEST_CASE_METHOD(TApp, "NoFallThroughOpts", "[subcom]") {
int val{1};
app.add_option("--val", val);
app.add_subcommand("sub");
args = {"sub", "--val", "2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, NoFallThroughPositionals) {
+TEST_CASE_METHOD(TApp, "NoFallThroughPositionals", "[subcom]") {
int val{1};
app.add_option("val", val);
app.add_subcommand("sub");
args = {"sub", "2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, NoFallThroughOptsWithTerminator) {
+TEST_CASE_METHOD(TApp, "NoFallThroughOptsWithTerminator", "[subcom]") {
int val{1};
app.add_option("--val", val);
@@ -386,10 +382,10 @@ TEST_F(TApp, NoFallThroughOptsWithTerminator) {
args = {"sub", "++", "--val", "2"};
run();
- EXPECT_EQ(val, 2);
+ CHECK(2 == val);
}
-TEST_F(TApp, NoFallThroughPositionalsWithTerminator) {
+TEST_CASE_METHOD(TApp, "NoFallThroughPositionalsWithTerminator", "[subcom]") {
int val{1};
app.add_option("val", val);
@@ -397,15 +393,15 @@ TEST_F(TApp, NoFallThroughPositionalsWithTerminator) {
args = {"sub", "++", "2"};
run();
- EXPECT_EQ(val, 2);
+ CHECK(2 == val);
// try with positional only mark
args = {"sub", "--", "3"};
run();
- EXPECT_EQ(val, 3);
+ CHECK(3 == val);
}
-TEST_F(TApp, NamelessSubComPositionals) {
+TEST_CASE_METHOD(TApp, "NamelessSubComPositionals", "[subcom]") {
auto sub = app.add_subcommand();
int val{1};
@@ -413,21 +409,21 @@ TEST_F(TApp, NamelessSubComPositionals) {
args = {"2"};
run();
- EXPECT_EQ(val, 2);
+ CHECK(2 == val);
}
-TEST_F(TApp, NamelessSubWithSub) {
+TEST_CASE_METHOD(TApp, "NamelessSubWithSub", "[subcom]") {
auto sub = app.add_subcommand();
auto subsub = sub->add_subcommand("val");
args = {"val"};
run();
- EXPECT_TRUE(subsub->parsed());
- EXPECT_TRUE(app.got_subcommand("val"));
+ CHECK(subsub->parsed());
+ CHECK(app.got_subcommand("val"));
}
-TEST_F(TApp, NamelessSubWithMultipleSub) {
+TEST_CASE_METHOD(TApp, "NamelessSubWithMultipleSub", "[subcom]") {
auto sub1 = app.add_subcommand();
auto sub2 = app.add_subcommand();
@@ -437,33 +433,33 @@ TEST_F(TApp, NamelessSubWithMultipleSub) {
auto sub2sub2 = sub2->add_subcommand("val4");
args = {"val1"};
run();
- EXPECT_TRUE(sub1sub1->parsed());
- EXPECT_TRUE(app.got_subcommand("val1"));
+ CHECK(sub1sub1->parsed());
+ CHECK(app.got_subcommand("val1"));
args = {"val2"};
run();
- EXPECT_TRUE(sub1sub2->parsed());
- EXPECT_TRUE(app.got_subcommand("val2"));
+ CHECK(sub1sub2->parsed());
+ CHECK(app.got_subcommand("val2"));
args = {"val3"};
run();
- EXPECT_TRUE(sub2sub1->parsed());
- EXPECT_TRUE(app.got_subcommand("val3"));
+ CHECK(sub2sub1->parsed());
+ CHECK(app.got_subcommand("val3"));
args = {"val4"};
run();
- EXPECT_TRUE(sub2sub2->parsed());
- EXPECT_TRUE(app.got_subcommand("val4"));
+ CHECK(sub2sub2->parsed());
+ CHECK(app.got_subcommand("val4"));
args = {"val4", "val1"};
run();
- EXPECT_TRUE(sub2sub2->parsed());
- EXPECT_TRUE(app.got_subcommand("val4"));
- EXPECT_TRUE(sub1sub1->parsed());
- EXPECT_TRUE(app.got_subcommand("val1"));
+ CHECK(sub2sub2->parsed());
+ CHECK(app.got_subcommand("val4"));
+ CHECK(sub1sub1->parsed());
+ CHECK(app.got_subcommand("val1"));
}
-TEST_F(TApp, Nameless4LayerDeep) {
+TEST_CASE_METHOD(TApp, "Nameless4LayerDeep", "[subcom]") {
auto sub = app.add_subcommand();
auto ssub = sub->add_subcommand();
@@ -474,12 +470,12 @@ TEST_F(TApp, Nameless4LayerDeep) {
args = {"val"};
run();
- EXPECT_TRUE(sssssub->parsed());
- EXPECT_TRUE(app.got_subcommand("val"));
+ CHECK(sssssub->parsed());
+ CHECK(app.got_subcommand("val"));
}
/// Put subcommands in some crazy pattern and make everything still works
-TEST_F(TApp, Nameless4LayerDeepMulti) {
+TEST_CASE_METHOD(TApp, "Nameless4LayerDeepMulti", "[subcom]") {
auto sub1 = app.add_subcommand();
auto sub2 = app.add_subcommand();
@@ -495,31 +491,31 @@ TEST_F(TApp, Nameless4LayerDeepMulti) {
sssub2->add_subcommand("val5");
args = {"val1"};
run();
- EXPECT_TRUE(app.got_subcommand("val1"));
+ CHECK(app.got_subcommand("val1"));
args = {"val2"};
run();
- EXPECT_TRUE(app.got_subcommand("val2"));
+ CHECK(app.got_subcommand("val2"));
args = {"val3"};
run();
- EXPECT_TRUE(app.got_subcommand("val3"));
+ CHECK(app.got_subcommand("val3"));
args = {"val4"};
run();
- EXPECT_TRUE(app.got_subcommand("val4"));
+ CHECK(app.got_subcommand("val4"));
args = {"val5"};
run();
- EXPECT_TRUE(app.got_subcommand("val5"));
+ CHECK(app.got_subcommand("val5"));
args = {"val4", "val1", "val5"};
run();
- EXPECT_TRUE(app.got_subcommand("val4"));
- EXPECT_TRUE(app.got_subcommand("val1"));
- EXPECT_TRUE(app.got_subcommand("val5"));
+ CHECK(app.got_subcommand("val4"));
+ CHECK(app.got_subcommand("val1"));
+ CHECK(app.got_subcommand("val5"));
}
-TEST_F(TApp, FallThroughRegular) {
+TEST_CASE_METHOD(TApp, "FallThroughRegular", "[subcom]") {
app.fallthrough();
int val{1};
app.add_option("--val", val);
@@ -531,7 +527,7 @@ TEST_F(TApp, FallThroughRegular) {
run();
}
-TEST_F(TApp, FallThroughShort) {
+TEST_CASE_METHOD(TApp, "FallThroughShort", "[subcom]") {
app.fallthrough();
int val{1};
app.add_option("-v", val);
@@ -543,7 +539,7 @@ TEST_F(TApp, FallThroughShort) {
run();
}
-TEST_F(TApp, FallThroughPositional) {
+TEST_CASE_METHOD(TApp, "FallThroughPositional", "[subcom]") {
app.fallthrough();
int val{1};
app.add_option("val", val);
@@ -555,7 +551,7 @@ TEST_F(TApp, FallThroughPositional) {
run();
}
-TEST_F(TApp, FallThroughEquals) {
+TEST_CASE_METHOD(TApp, "FallThroughEquals", "[subcom]") {
app.fallthrough();
int val{1};
app.add_option("--val", val);
@@ -567,7 +563,7 @@ TEST_F(TApp, FallThroughEquals) {
run();
}
-TEST_F(TApp, EvilParseFallthrough) {
+TEST_CASE_METHOD(TApp, "EvilParseFallthrough", "[subcom]") {
app.fallthrough();
int val1{0}, val2{0};
app.add_option("--val1", val1);
@@ -579,11 +575,11 @@ TEST_F(TApp, EvilParseFallthrough) {
// Should not throw
run();
- EXPECT_EQ(1, val1);
- EXPECT_EQ(2, val2);
+ CHECK(val1 == 1);
+ CHECK(val2 == 2);
}
-TEST_F(TApp, CallbackOrdering) {
+TEST_CASE_METHOD(TApp, "CallbackOrdering", "[subcom]") {
app.fallthrough();
int val{1}, sub_val{0};
app.add_option("--val", val);
@@ -593,16 +589,16 @@ TEST_F(TApp, CallbackOrdering) {
args = {"sub", "--val=2"};
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(2, sub_val);
+ CHECK(val == 2);
+ CHECK(sub_val == 2);
args = {"--val=2", "sub"};
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(2, sub_val);
+ CHECK(val == 2);
+ CHECK(sub_val == 2);
}
-TEST_F(TApp, CallbackOrderingImmediate) {
+TEST_CASE_METHOD(TApp, "CallbackOrderingImmediate", "[subcom]") {
app.fallthrough();
int val{1}, sub_val{0};
app.add_option("--val", val);
@@ -612,16 +608,16 @@ TEST_F(TApp, CallbackOrderingImmediate) {
args = {"sub", "--val=2"};
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(1, sub_val);
+ CHECK(val == 2);
+ CHECK(sub_val == 1);
args = {"--val=2", "sub"};
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(2, sub_val);
+ CHECK(val == 2);
+ CHECK(sub_val == 2);
}
-TEST_F(TApp, CallbackOrderingImmediateMain) {
+TEST_CASE_METHOD(TApp, "CallbackOrderingImmediateMain", "[subcom]") {
app.fallthrough();
int val{0}, sub_val{0};
@@ -633,24 +629,24 @@ TEST_F(TApp, CallbackOrderingImmediateMain) {
app.callback([&val]() { val = 1; });
args = {"sub"};
run();
- EXPECT_EQ(1, val);
- EXPECT_EQ(0, sub_val);
+ CHECK(val == 1);
+ CHECK(sub_val == 0);
// the main app callback should run before the subcommand callbacks
app.immediate_callback();
val = 0; // reset value
run();
- EXPECT_EQ(2, val);
- EXPECT_EQ(1, sub_val);
+ CHECK(val == 2);
+ CHECK(sub_val == 1);
// the subcommand callback now runs immediately after processing and before the main app callback again
sub->immediate_callback();
val = 0; // reset value
run();
- EXPECT_EQ(1, val);
- EXPECT_EQ(0, sub_val);
+ CHECK(val == 1);
+ CHECK(sub_val == 0);
}
// Test based on issue #308
-TEST_F(TApp, CallbackOrderingImmediateModeOrder) {
+TEST_CASE_METHOD(TApp, "CallbackOrderingImmediateModeOrder", "[subcom]") {
app.require_subcommand(1, 1);
std::vector<int> v;
@@ -660,81 +656,81 @@ TEST_F(TApp, CallbackOrderingImmediateModeOrder) {
args = {"hello"};
run();
// immediate_callback inherited
- ASSERT_EQ(v.size(), 2u);
- EXPECT_EQ(v[0], 1);
- EXPECT_EQ(v[1], 2);
+ REQUIRE(2u == v.size());
+ CHECK(1 == v[0]);
+ CHECK(2 == v[1]);
v.clear();
sub->immediate_callback(true);
run();
// immediate_callback is now triggered for the main first
- ASSERT_EQ(v.size(), 2u);
- EXPECT_EQ(v[0], 2);
- EXPECT_EQ(v[1], 1);
+ REQUIRE(2u == v.size());
+ CHECK(2 == v[0]);
+ CHECK(1 == v[1]);
}
-TEST_F(TApp, RequiredSubCom) {
+TEST_CASE_METHOD(TApp, "RequiredSubCom", "[subcom]") {
app.add_subcommand("sub1");
app.add_subcommand("sub2");
app.require_subcommand();
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"sub1"};
run();
}
-TEST_F(TApp, SubComExtras) {
+TEST_CASE_METHOD(TApp, "SubComExtras", "[subcom]") {
app.allow_extras();
auto sub = app.add_subcommand("sub");
args = {"extra", "sub"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"extra"}));
- EXPECT_EQ(sub->remaining(), std::vector<std::string>());
+ CHECK(std::vector<std::string>({"extra"}) == app.remaining());
+ CHECK(std::vector<std::string>() == sub->remaining());
args = {"extra1", "extra2", "sub"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"extra1", "extra2"}));
- EXPECT_EQ(sub->remaining(), std::vector<std::string>());
+ CHECK(std::vector<std::string>({"extra1", "extra2"}) == app.remaining());
+ CHECK(std::vector<std::string>() == sub->remaining());
args = {"sub", "extra1", "extra2"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>());
- EXPECT_EQ(sub->remaining(), std::vector<std::string>({"extra1", "extra2"}));
+ CHECK(std::vector<std::string>() == app.remaining());
+ CHECK(std::vector<std::string>({"extra1", "extra2"}) == sub->remaining());
args = {"extra1", "extra2", "sub", "extra3", "extra4"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"extra1", "extra2"}));
- EXPECT_EQ(app.remaining(true), std::vector<std::string>({"extra1", "extra2", "extra3", "extra4"}));
- EXPECT_EQ(sub->remaining(), std::vector<std::string>({"extra3", "extra4"}));
+ CHECK(std::vector<std::string>({"extra1", "extra2"}) == app.remaining());
+ CHECK(std::vector<std::string>({"extra1", "extra2", "extra3", "extra4"}) == app.remaining(true));
+ CHECK(std::vector<std::string>({"extra3", "extra4"}) == sub->remaining());
}
-TEST_F(TApp, Required1SubCom) {
+TEST_CASE_METHOD(TApp, "Required1SubCom", "[subcom]") {
app.require_subcommand(1);
app.add_subcommand("sub1");
app.add_subcommand("sub2");
app.add_subcommand("sub3");
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
args = {"sub1"};
run();
args = {"sub1", "sub2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, BadSubcommandSearch) {
+TEST_CASE_METHOD(TApp, "BadSubcommandSearch", "[subcom]") {
auto one = app.add_subcommand("one");
auto two = one->add_subcommand("two");
- EXPECT_THROW(app.get_subcommand(two), CLI::OptionNotFound);
- EXPECT_THROW(app.get_subcommand_ptr(two), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app.get_subcommand(two), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app.get_subcommand_ptr(two), CLI::OptionNotFound);
}
-TEST_F(TApp, PrefixProgram) {
+TEST_CASE_METHOD(TApp, "PrefixProgram", "[subcom]") {
app.prefix_command();
@@ -743,10 +739,10 @@ TEST_F(TApp, PrefixProgram) {
args = {"--simple", "other", "--simple", "--mine"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"other", "--simple", "--mine"}));
+ CHECK(std::vector<std::string>({"other", "--simple", "--mine"}) == app.remaining());
}
-TEST_F(TApp, PrefixNoSeparation) {
+TEST_CASE_METHOD(TApp, "PrefixNoSeparation", "[subcom]") {
app.prefix_command();
@@ -755,10 +751,10 @@ TEST_F(TApp, PrefixNoSeparation) {
args = {"--vals", "1", "2", "3", "other"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, PrefixSeparation) {
+TEST_CASE_METHOD(TApp, "PrefixSeparation", "[subcom]") {
app.prefix_command();
@@ -769,11 +765,11 @@ TEST_F(TApp, PrefixSeparation) {
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"other"}));
- EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+ CHECK(std::vector<std::string>({"other"}) == app.remaining());
+ CHECK(std::vector<int>({1, 2, 3}) == vals);
}
-TEST_F(TApp, PrefixSubcom) {
+TEST_CASE_METHOD(TApp, "PrefixSubcom", "[subcom]") {
auto subc = app.add_subcommand("subc");
subc->prefix_command();
@@ -782,19 +778,19 @@ TEST_F(TApp, PrefixSubcom) {
args = {"--simple", "subc", "other", "--simple", "--mine"};
run();
- EXPECT_EQ(app.remaining_size(), 0u);
- EXPECT_EQ(app.remaining_size(true), 3u);
- EXPECT_EQ(subc->remaining(), std::vector<std::string>({"other", "--simple", "--mine"}));
+ CHECK(0u == app.remaining_size());
+ CHECK(3u == app.remaining_size(true));
+ CHECK(std::vector<std::string>({"other", "--simple", "--mine"}) == subc->remaining());
}
-TEST_F(TApp, InheritHelpAllFlag) {
+TEST_CASE_METHOD(TApp, "InheritHelpAllFlag", "[subcom]") {
app.set_help_all_flag("--help-all");
auto subc = app.add_subcommand("subc");
auto help_opt_list = subc->get_options([](const CLI::Option *opt) { return opt->get_name() == "--help-all"; });
- EXPECT_EQ(help_opt_list.size(), 1u);
+ CHECK(1u == help_opt_list.size());
}
-TEST_F(TApp, RequiredPosInSubcommand) {
+TEST_CASE_METHOD(TApp, "RequiredPosInSubcommand", "[subcom]") {
app.require_subcommand();
std::string bar;
@@ -806,13 +802,13 @@ TEST_F(TApp, RequiredPosInSubcommand) {
args = {"foo", "abc"};
run();
- EXPECT_EQ(bar, "abc");
+ CHECK("abc" == bar);
args = {"baz", "cba"};
run();
- EXPECT_EQ(bar, "cba");
+ CHECK("cba" == bar);
args = {};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
struct SubcommandProgram : public TApp {
@@ -839,54 +835,54 @@ struct SubcommandProgram : public TApp {
}
};
-TEST_F(SubcommandProgram, Working) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand Working", "[subcom]") {
args = {"-d", "start", "-ffilename"};
run();
- EXPECT_EQ(1, dummy);
- EXPECT_EQ(start, app.get_subcommands().at(0));
- EXPECT_EQ("filename", file);
+ CHECK(dummy == 1);
+ CHECK(app.get_subcommands().at(0) == start);
+ CHECK(file == "filename");
}
-TEST_F(SubcommandProgram, Spare) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand Spare", "[subcom]") {
args = {"extra", "-d", "start", "-ffilename"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(SubcommandProgram, SpareSub) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand SpareSub", "[subcom]") {
args = {"-d", "start", "spare", "-ffilename"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(SubcommandProgram, Multiple) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand Multiple", "[subcom]") {
args = {"-d", "start", "-ffilename", "stop"};
run();
- EXPECT_EQ(2u, app.get_subcommands().size());
- EXPECT_EQ(1, dummy);
- EXPECT_EQ("filename", file);
+ CHECK(app.get_subcommands().size() == 2u);
+ CHECK(dummy == 1);
+ CHECK(file == "filename");
}
-TEST_F(SubcommandProgram, MultipleOtherOrder) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand MultipleOtherOrder", "[subcom]") {
args = {"start", "-d", "-ffilename", "stop"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(SubcommandProgram, MultipleArgs) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand MultipleArgs", "[subcom]") {
args = {"start", "stop"};
run();
- EXPECT_EQ(2u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().size() == 2u);
}
-TEST_F(SubcommandProgram, CaseCheck) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand CaseCheck", "[subcom]") {
args = {"Start"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"start"};
run();
@@ -898,32 +894,32 @@ TEST_F(SubcommandProgram, CaseCheck) {
run();
}
-TEST_F(TApp, SubcomInheritCaseCheck) {
+TEST_CASE_METHOD(TApp, "SubcomInheritCaseCheck", "[subcom]") {
app.ignore_case();
auto sub1 = app.add_subcommand("sub1");
auto sub2 = app.add_subcommand("sub2");
run();
- EXPECT_EQ(0u, app.get_subcommands().size());
- EXPECT_EQ(2u, app.get_subcommands({}).size());
- EXPECT_EQ(1u, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub1"; }).size());
+ CHECK(app.get_subcommands().size() == 0u);
+ CHECK(app.get_subcommands({}).size() == 2u);
+ CHECK(app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub1"; }).size() == 1u);
args = {"SuB1"};
run();
- EXPECT_EQ(sub1, app.get_subcommands().at(0));
- EXPECT_EQ(1u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().at(0) == sub1);
+ CHECK(app.get_subcommands().size() == 1u);
app.clear();
- EXPECT_EQ(0u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().size() == 0u);
args = {"sUb2"};
run();
- EXPECT_EQ(sub2, app.get_subcommands().at(0));
+ CHECK(app.get_subcommands().at(0) == sub2);
}
-TEST_F(SubcommandProgram, UnderscoreCheck) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand UnderscoreCheck", "[subcom]") {
args = {"start_"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"start"};
run();
@@ -935,54 +931,54 @@ TEST_F(SubcommandProgram, UnderscoreCheck) {
run();
}
-TEST_F(TApp, SubcomInheritUnderscoreCheck) {
+TEST_CASE_METHOD(TApp, "SubcomInheritUnderscoreCheck", "[subcom]") {
app.ignore_underscore();
auto sub1 = app.add_subcommand("sub_option1");
auto sub2 = app.add_subcommand("sub_option2");
run();
- EXPECT_EQ(0u, app.get_subcommands().size());
- EXPECT_EQ(2u, app.get_subcommands({}).size());
- EXPECT_EQ(1u, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub_option1"; }).size());
+ CHECK(app.get_subcommands().size() == 0u);
+ CHECK(app.get_subcommands({}).size() == 2u);
+ CHECK(app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub_option1"; }).size() == 1u);
args = {"suboption1"};
run();
- EXPECT_EQ(sub1, app.get_subcommands().at(0));
- EXPECT_EQ(1u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().at(0) == sub1);
+ CHECK(app.get_subcommands().size() == 1u);
app.clear();
- EXPECT_EQ(0u, app.get_subcommands().size());
+ CHECK(app.get_subcommands().size() == 0u);
args = {"_suboption2"};
run();
- EXPECT_EQ(sub2, app.get_subcommands().at(0));
+ CHECK(app.get_subcommands().at(0) == sub2);
}
-TEST_F(SubcommandProgram, HelpOrder) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand HelpOrder", "[subcom]") {
args = {"-h"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
args = {"start", "-h"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
args = {"-h", "start"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
}
-TEST_F(SubcommandProgram, HelpAllOrder) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand HelpAllOrder", "[subcom]") {
args = {"--help-all"};
- EXPECT_THROW(run(), CLI::CallForAllHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForAllHelp);
args = {"start", "--help-all"};
- EXPECT_THROW(run(), CLI::CallForAllHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForAllHelp);
args = {"--help-all", "start"};
- EXPECT_THROW(run(), CLI::CallForAllHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForAllHelp);
}
-TEST_F(SubcommandProgram, Callbacks) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand Callbacks", "[subcom]") {
start->callback([]() { throw CLI::Success(); });
@@ -990,63 +986,63 @@ TEST_F(SubcommandProgram, Callbacks) {
args = {"start"};
- EXPECT_THROW(run(), CLI::Success);
+ CHECK_THROWS_AS(run(), CLI::Success);
}
-TEST_F(SubcommandProgram, Groups) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand Groups", "[subcom]") {
std::string help = app.help();
- EXPECT_THAT(help, Not(HasSubstr("More Commands:")));
- EXPECT_THAT(help, HasSubstr("Subcommands:"));
+ CHECK_THAT(help, !Contains("More Commands:"));
+ CHECK_THAT(help, Contains("Subcommands:"));
start->group("More Commands");
help = app.help();
- EXPECT_THAT(help, HasSubstr("More Commands:"));
- EXPECT_THAT(help, HasSubstr("Subcommands:"));
+ CHECK_THAT(help, Contains("More Commands:"));
+ CHECK_THAT(help, Contains("Subcommands:"));
// Case is ignored but for the first subcommand in a group.
stop->group("more commands");
help = app.help();
- EXPECT_THAT(help, HasSubstr("More Commands:"));
- EXPECT_THAT(help, Not(HasSubstr("Subcommands:")));
+ CHECK_THAT(help, Contains("More Commands:"));
+ CHECK_THAT(help, !Contains("Subcommands:"));
}
-TEST_F(SubcommandProgram, ExtrasErrors) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand ExtrasErrors", "[subcom]") {
args = {"one", "two", "start", "three", "four"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"start", "three", "four"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"one", "two"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(SubcommandProgram, OrderedExtras) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand OrderedExtras", "[subcom]") {
app.allow_extras();
args = {"one", "two", "start", "three", "four"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
start->allow_extras();
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(start->remaining(), std::vector<std::string>({"three", "four"}));
- EXPECT_EQ(app.remaining(true), std::vector<std::string>({"one", "two", "three", "four"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == app.remaining());
+ CHECK(std::vector<std::string>({"three", "four"}) == start->remaining());
+ CHECK(std::vector<std::string>({"one", "two", "three", "four"}) == app.remaining(true));
args = {"one", "two", "start", "three", "--", "four"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"one", "two", "four"}));
- EXPECT_EQ(start->remaining(), std::vector<std::string>({"three"}));
- EXPECT_EQ(app.remaining(true), std::vector<std::string>({"one", "two", "four", "three"}));
+ CHECK(std::vector<std::string>({"one", "two", "four"}) == app.remaining());
+ CHECK(std::vector<std::string>({"three"}) == start->remaining());
+ CHECK(std::vector<std::string>({"one", "two", "four", "three"}) == app.remaining(true));
}
-TEST_F(SubcommandProgram, MixedOrderExtras) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand MixedOrderExtras", "[subcom]") {
app.allow_extras();
start->allow_extras();
@@ -1055,50 +1051,50 @@ TEST_F(SubcommandProgram, MixedOrderExtras) {
args = {"one", "two", "start", "three", "four", "stop", "five", "six"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(start->remaining(), std::vector<std::string>({"three", "four"}));
- EXPECT_EQ(stop->remaining(), std::vector<std::string>({"five", "six"}));
- EXPECT_EQ(app.remaining(true), std::vector<std::string>({"one", "two", "three", "four", "five", "six"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == app.remaining());
+ CHECK(std::vector<std::string>({"three", "four"}) == start->remaining());
+ CHECK(std::vector<std::string>({"five", "six"}) == stop->remaining());
+ CHECK(std::vector<std::string>({"one", "two", "three", "four", "five", "six"}) == app.remaining(true));
args = {"one", "two", "stop", "three", "four", "start", "five", "six"};
run();
- EXPECT_EQ(app.remaining(), std::vector<std::string>({"one", "two"}));
- EXPECT_EQ(stop->remaining(), std::vector<std::string>({"three", "four"}));
- EXPECT_EQ(start->remaining(), std::vector<std::string>({"five", "six"}));
- EXPECT_EQ(app.remaining(true), std::vector<std::string>({"one", "two", "three", "four", "five", "six"}));
+ CHECK(std::vector<std::string>({"one", "two"}) == app.remaining());
+ CHECK(std::vector<std::string>({"three", "four"}) == stop->remaining());
+ CHECK(std::vector<std::string>({"five", "six"}) == start->remaining());
+ CHECK(std::vector<std::string>({"one", "two", "three", "four", "five", "six"}) == app.remaining(true));
}
-TEST_F(SubcommandProgram, CallbackOrder) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand CallbackOrder", "[subcom]") {
std::vector<int> callback_order;
start->callback([&callback_order]() { callback_order.push_back(1); });
stop->callback([&callback_order]() { callback_order.push_back(2); });
args = {"start", "stop"};
run();
- EXPECT_EQ(callback_order, std::vector<int>({1, 2}));
+ CHECK(std::vector<int>({1, 2}) == callback_order);
callback_order.clear();
args = {"stop", "start"};
run();
- EXPECT_EQ(callback_order, std::vector<int>({2, 1}));
+ CHECK(std::vector<int>({2, 1}) == callback_order);
}
-TEST_F(SubcommandProgram, CallbackOrderImmediate) {
+TEST_CASE_METHOD(SubcommandProgram, "Subcommand CallbackOrderImmediate", "[subcom]") {
std::vector<int> callback_order;
start->callback([&callback_order]() { callback_order.push_back(1); })->immediate_callback();
stop->callback([&callback_order]() { callback_order.push_back(2); });
args = {"start", "stop", "start"};
run();
- EXPECT_EQ(callback_order, std::vector<int>({1, 1, 2}));
+ CHECK(std::vector<int>({1, 1, 2}) == callback_order);
callback_order.clear();
args = {"stop", "start", "stop", "start"};
run();
- EXPECT_EQ(callback_order, std::vector<int>({1, 1, 2}));
+ CHECK(std::vector<int>({1, 1, 2}) == callback_order);
}
struct ManySubcommands : public TApp {
@@ -1121,137 +1117,137 @@ struct ManySubcommands : public TApp {
ManySubcommands &operator=(const ManySubcommands &) = delete;
};
-TEST_F(ManySubcommands, Required1Exact) {
+TEST_CASE_METHOD(ManySubcommands, "Required1Exact", "[subcom]") {
app.require_subcommand(1);
run();
- EXPECT_EQ(sub1->remaining(), vs_t({"sub2", "sub3"}));
- EXPECT_EQ(app.remaining(true), vs_t({"sub2", "sub3"}));
+ CHECK(vs_t({"sub2", "sub3"}) == sub1->remaining());
+ CHECK(vs_t({"sub2", "sub3"}) == app.remaining(true));
}
-TEST_F(ManySubcommands, Required2Exact) {
+TEST_CASE_METHOD(ManySubcommands, "Required2Exact", "[subcom]") {
app.require_subcommand(2);
run();
- EXPECT_EQ(sub2->remaining(), vs_t({"sub3"}));
+ CHECK(vs_t({"sub3"}) == sub2->remaining());
}
-TEST_F(ManySubcommands, Required4Failure) {
+TEST_CASE_METHOD(ManySubcommands, "Required4Failure", "[subcom]") {
app.require_subcommand(4);
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(ManySubcommands, RemoveSub) {
+TEST_CASE_METHOD(ManySubcommands, "RemoveSub", "[subcom]") {
run();
- EXPECT_EQ(app.remaining_size(true), 0u);
+ CHECK(0u == app.remaining_size(true));
app.remove_subcommand(sub1);
app.allow_extras();
run();
- EXPECT_EQ(app.remaining_size(true), 1u);
+ CHECK(1u == app.remaining_size(true));
}
-TEST_F(ManySubcommands, RemoveSubFail) {
+TEST_CASE_METHOD(ManySubcommands, "RemoveSubFail", "[subcom]") {
auto sub_sub = sub1->add_subcommand("subsub");
- EXPECT_FALSE(app.remove_subcommand(sub_sub));
- EXPECT_TRUE(sub1->remove_subcommand(sub_sub));
- EXPECT_FALSE(app.remove_subcommand(nullptr));
+ CHECK(!app.remove_subcommand(sub_sub));
+ CHECK(sub1->remove_subcommand(sub_sub));
+ CHECK(!app.remove_subcommand(nullptr));
}
-TEST_F(ManySubcommands, manyIndexQuery) {
+TEST_CASE_METHOD(ManySubcommands, "manyIndexQuery", "[subcom]") {
auto s1 = app.get_subcommand(0);
auto s2 = app.get_subcommand(1);
auto s3 = app.get_subcommand(2);
auto s4 = app.get_subcommand(3);
- EXPECT_EQ(s1, sub1);
- EXPECT_EQ(s2, sub2);
- EXPECT_EQ(s3, sub3);
- EXPECT_EQ(s4, sub4);
- EXPECT_THROW(app.get_subcommand(4), CLI::OptionNotFound);
+ CHECK(sub1 == s1);
+ CHECK(sub2 == s2);
+ CHECK(sub3 == s3);
+ CHECK(sub4 == s4);
+ CHECK_THROWS_AS(app.get_subcommand(4), CLI::OptionNotFound);
auto s0 = app.get_subcommand();
- EXPECT_EQ(s0, sub1);
+ CHECK(sub1 == s0);
}
-TEST_F(ManySubcommands, manyIndexQueryPtr) {
+TEST_CASE_METHOD(ManySubcommands, "manyIndexQueryPtr", "[subcom]") {
auto s1 = app.get_subcommand_ptr(0);
auto s2 = app.get_subcommand_ptr(1);
auto s3 = app.get_subcommand_ptr(2);
auto s4 = app.get_subcommand_ptr(3);
- EXPECT_EQ(s1.get(), sub1);
- EXPECT_EQ(s2.get(), sub2);
- EXPECT_EQ(s3.get(), sub3);
- EXPECT_EQ(s4.get(), sub4);
- EXPECT_THROW(app.get_subcommand_ptr(4), CLI::OptionNotFound);
+ CHECK(sub1 == s1.get());
+ CHECK(sub2 == s2.get());
+ CHECK(sub3 == s3.get());
+ CHECK(sub4 == s4.get());
+ CHECK_THROWS_AS(app.get_subcommand_ptr(4), CLI::OptionNotFound);
}
-TEST_F(ManySubcommands, Required1Fuzzy) {
+TEST_CASE_METHOD(ManySubcommands, "Required1Fuzzy", "[subcom]") {
app.require_subcommand(0, 1);
run();
- EXPECT_EQ(sub1->remaining(), vs_t({"sub2", "sub3"}));
+ CHECK(vs_t({"sub2", "sub3"}) == sub1->remaining());
app.require_subcommand(-1);
run();
- EXPECT_EQ(sub1->remaining(), vs_t({"sub2", "sub3"}));
+ CHECK(vs_t({"sub2", "sub3"}) == sub1->remaining());
}
-TEST_F(ManySubcommands, Required2Fuzzy) {
+TEST_CASE_METHOD(ManySubcommands, "Required2Fuzzy", "[subcom]") {
app.require_subcommand(0, 2);
run();
- EXPECT_EQ(sub2->remaining(), vs_t({"sub3"}));
- EXPECT_EQ(app.remaining(true), vs_t({"sub3"}));
+ CHECK(vs_t({"sub3"}) == sub2->remaining());
+ CHECK(vs_t({"sub3"}) == app.remaining(true));
app.require_subcommand(-2);
run();
- EXPECT_EQ(sub2->remaining(), vs_t({"sub3"}));
+ CHECK(vs_t({"sub3"}) == sub2->remaining());
}
-TEST_F(ManySubcommands, Unlimited) {
+TEST_CASE_METHOD(ManySubcommands, "Unlimited", "[subcom]") {
run();
- EXPECT_EQ(app.remaining(true), vs_t());
+ CHECK(vs_t() == app.remaining(true));
app.require_subcommand();
run();
- EXPECT_EQ(app.remaining(true), vs_t());
+ CHECK(vs_t() == app.remaining(true));
app.require_subcommand(2, 0); // 2 or more
run();
- EXPECT_EQ(app.remaining(true), vs_t());
+ CHECK(vs_t() == app.remaining(true));
}
-TEST_F(ManySubcommands, HelpFlags) {
+TEST_CASE_METHOD(ManySubcommands, "HelpFlags", "[subcom]") {
args = {"-h"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
args = {"sub2", "-h"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
args = {"-h", "sub2"};
- EXPECT_THROW(run(), CLI::CallForHelp);
+ CHECK_THROWS_AS(run(), CLI::CallForHelp);
}
-TEST_F(ManySubcommands, MaxCommands) {
+TEST_CASE_METHOD(ManySubcommands, "MaxCommands", "[subcom]") {
app.require_subcommand(2);
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
// The extra subcommand counts as an extra
args = {"sub1", "sub2", "sub3"};
- EXPECT_NO_THROW(run());
- EXPECT_EQ(sub2->remaining().size(), 1u);
- EXPECT_EQ(app.count_all(), 2u);
+ CHECK_NOTHROW(run());
+ CHECK(1u == sub2->remaining().size());
+ CHECK(2u == app.count_all());
// Currently, setting sub2 to throw causes an extras error
// In the future, would passing on up to app's extras be better?
@@ -1262,31 +1258,31 @@ TEST_F(ManySubcommands, MaxCommands) {
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1", "sub2", "sub3"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(ManySubcommands, SubcommandExclusion) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandExclusion", "[subcom]") {
sub1->excludes(sub3);
sub2->excludes(sub3);
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1", "sub2", "sub3"};
- EXPECT_THROW(run(), CLI::ExcludesError);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
args = {"sub1", "sub2", "sub4"};
- EXPECT_NO_THROW(run());
- EXPECT_EQ(app.count_all(), 3u);
+ CHECK_NOTHROW(run());
+ CHECK(3u == app.count_all());
args = {"sub3", "sub4"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManySubcommands, SubcommandOptionExclusion) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandOptionExclusion", "[subcom]") {
auto excluder_flag = app.add_flag("--exclude");
sub1->excludes(excluder_flag)->fallthrough();
@@ -1294,78 +1290,78 @@ TEST_F(ManySubcommands, SubcommandOptionExclusion) {
sub3->fallthrough();
sub4->fallthrough();
args = {"sub3", "sub4", "--exclude"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1", "sub3", "--exclude"};
- EXPECT_THROW(run(), CLI::ExcludesError);
- EXPECT_TRUE(sub1->remove_excludes(excluder_flag));
- EXPECT_NO_THROW(run());
- EXPECT_FALSE(sub1->remove_excludes(excluder_flag));
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
+ CHECK(sub1->remove_excludes(excluder_flag));
+ CHECK_NOTHROW(run());
+ CHECK(!sub1->remove_excludes(excluder_flag));
args = {"--exclude", "sub2", "sub4"};
- EXPECT_THROW(run(), CLI::ExcludesError);
- EXPECT_EQ(sub1->excludes(excluder_flag), sub1);
+ CHECK_THROWS_AS(run(), CLI::ExcludesError);
+ CHECK(sub1 == sub1->excludes(excluder_flag));
args = {"sub1", "--exclude", "sub2", "sub4"};
try {
run();
} catch(const CLI::ExcludesError &ee) {
- EXPECT_NE(std::string(ee.what()).find("sub1"), std::string::npos);
+ CHECK(std::string::npos != std::string(ee.what()).find("sub1"));
}
}
-TEST_F(ManySubcommands, SubcommandNeeds) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandNeeds", "[subcom]") {
sub1->needs(sub2);
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
sub1->needs(sub3);
args = {"sub1", "sub2", "sub3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1", "sub2", "sub4"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"sub1", "sub2", "sub4"};
sub1->remove_needs(sub3);
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManySubcommands, SubcommandNeedsOptions) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandNeedsOptions", "[subcom]") {
auto opt = app.add_flag("--subactive");
sub1->needs(opt);
sub1->fallthrough();
args = {"sub1", "--subactive"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--subactive"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
auto opt2 = app.add_flag("--subactive2");
sub1->needs(opt2);
args = {"sub1", "--subactive"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
args = {"--subactive", "--subactive2", "sub1"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
sub1->remove_needs(opt2);
args = {"sub1", "--subactive"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManySubcommands, SubcommandNeedsOptionsCallbackOrdering) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandNeedsOptionsCallbackOrdering", "[subcom]") {
int count{0};
auto opt = app.add_flag("--subactive");
app.add_flag("--flag1");
@@ -1373,135 +1369,135 @@ TEST_F(ManySubcommands, SubcommandNeedsOptionsCallbackOrdering) {
sub1->fallthrough();
sub1->parse_complete_callback([&count]() { ++count; });
args = {"sub1", "--flag1", "sub1", "--subactive"};
- EXPECT_THROW(run(), CLI::RequiresError);
+ CHECK_THROWS_AS(run(), CLI::RequiresError);
// the subcommand has to pass validation by the first callback
sub1->immediate_callback(false);
// now since the callback executes after
- EXPECT_NO_THROW(run());
- EXPECT_EQ(count, 1);
+ CHECK_NOTHROW(run());
+ CHECK(1 == count);
sub1->immediate_callback();
args = {"--subactive", "sub1"};
// now the required is processed first
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManySubcommands, SubcommandNeedsFail) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandNeedsFail", "[subcom]") {
auto opt = app.add_flag("--subactive");
auto opt2 = app.add_flag("--dummy");
sub1->needs(opt);
- EXPECT_THROW(sub1->needs((CLI::Option *)nullptr), CLI::OptionNotFound);
- EXPECT_THROW(sub1->needs((CLI::App *)nullptr), CLI::OptionNotFound);
- EXPECT_THROW(sub1->needs(sub1), CLI::OptionNotFound);
+ CHECK_THROWS_AS(sub1->needs((CLI::Option *)nullptr), CLI::OptionNotFound);
+ CHECK_THROWS_AS(sub1->needs((CLI::App *)nullptr), CLI::OptionNotFound);
+ CHECK_THROWS_AS(sub1->needs(sub1), CLI::OptionNotFound);
- EXPECT_TRUE(sub1->remove_needs(opt));
- EXPECT_FALSE(sub1->remove_needs(opt2));
- EXPECT_FALSE(sub1->remove_needs(sub1));
+ CHECK(sub1->remove_needs(opt));
+ CHECK(!sub1->remove_needs(opt2));
+ CHECK(!sub1->remove_needs(sub1));
}
-TEST_F(ManySubcommands, SubcommandRequired) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandRequired", "[subcom]") {
sub1->required();
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1", "sub2", "sub3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub3", "sub4"};
- EXPECT_THROW(run(), CLI::RequiredError);
+ CHECK_THROWS_AS(run(), CLI::RequiredError);
}
-TEST_F(ManySubcommands, SubcommandDisabled) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandDisabled", "[subcom]") {
sub3->disabled();
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub1", "sub2", "sub3"};
app.allow_extras(false);
sub2->allow_extras(false);
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"sub3", "sub4"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
sub3->disabled(false);
args = {"sub3", "sub4"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
}
-TEST_F(ManySubcommands, SubcommandTriggeredOff) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandTriggeredOff", "[subcom]") {
app.allow_extras(false);
sub1->allow_extras(false);
sub2->allow_extras(false);
CLI::TriggerOff(sub1, sub2);
args = {"sub1", "sub2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"sub2", "sub1", "sub3"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
CLI::TriggerOff(sub1, {sub3, sub4});
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"sub1", "sub2", "sub4"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(ManySubcommands, SubcommandTriggeredOn) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandTriggeredOn", "[subcom]") {
app.allow_extras(false);
sub1->allow_extras(false);
sub2->allow_extras(false);
CLI::TriggerOn(sub1, sub2);
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub2", "sub1", "sub4"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
CLI::TriggerOn(sub1, {sub3, sub4});
sub2->disabled_by_default(false);
sub2->disabled(false);
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"sub3", "sub1", "sub2"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(ManySubcommands, SubcommandSilence) {
+TEST_CASE_METHOD(ManySubcommands, "SubcommandSilence", "[subcom]") {
sub1->silent();
args = {"sub1", "sub2"};
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
auto subs = app.get_subcommands();
- EXPECT_EQ(subs.size(), 1U);
+ CHECK(1U == subs.size());
sub1->silent(false);
- EXPECT_FALSE(sub1->get_silent());
+ CHECK(!sub1->get_silent());
run();
subs = app.get_subcommands();
- EXPECT_EQ(subs.size(), 2U);
+ CHECK(2U == subs.size());
}
-TEST_F(TApp, UnnamedSub) {
+TEST_CASE_METHOD(TApp, "UnnamedSub", "[subcom]") {
double val{0.0};
auto sub = app.add_subcommand("", "empty name");
auto opt = sub->add_option("-v,--value", val);
args = {"-v", "4.56"};
run();
- EXPECT_EQ(val, 4.56);
+ CHECK(4.56 == val);
// make sure unnamed sub options can be found from the main app
auto opt2 = app.get_option("-v");
- EXPECT_EQ(opt, opt2);
+ CHECK(opt2 == opt);
- EXPECT_THROW(app.get_option("--vvvv"), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app.get_option("--vvvv"), CLI::OptionNotFound);
// now test in the constant context
const auto &appC = app;
auto opt3 = appC.get_option("-v");
- EXPECT_EQ(opt3->get_name(), "--value");
- EXPECT_THROW(appC.get_option("--vvvv"), CLI::OptionNotFound);
+ CHECK("--value" == opt3->get_name());
+ CHECK_THROWS_AS(appC.get_option("--vvvv"), CLI::OptionNotFound);
}
-TEST_F(TApp, UnnamedSubMix) {
+TEST_CASE_METHOD(TApp, "UnnamedSubMix", "[subcom]") {
double val{0.0}, val2{0.0}, val3{0.0};
app.add_option("-t", val2);
auto sub1 = app.add_subcommand("", "empty name");
@@ -1511,13 +1507,13 @@ TEST_F(TApp, UnnamedSubMix) {
args = {"-m", "4.56", "-t", "5.93", "-v", "-3"};
run();
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
- EXPECT_EQ(val3, 4.56);
- EXPECT_EQ(app.count_all(), 3u);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
+ CHECK(4.56 == val3);
+ CHECK(3u == app.count_all());
}
-TEST_F(TApp, UnnamedSubMixExtras) {
+TEST_CASE_METHOD(TApp, "UnnamedSubMixExtras", "[subcom]") {
double val{0.0}, val2{0.0};
app.add_option("-t", val2);
auto sub = app.add_subcommand("", "empty name");
@@ -1525,26 +1521,26 @@ TEST_F(TApp, UnnamedSubMixExtras) {
args = {"-m", "4.56", "-t", "5.93", "-v", "-3"};
app.allow_extras();
run();
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
- EXPECT_EQ(app.remaining_size(), 2u);
- EXPECT_EQ(sub->remaining_size(), 0u);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
+ CHECK(2u == app.remaining_size());
+ CHECK(0u == sub->remaining_size());
}
-TEST_F(TApp, UnnamedSubNoExtras) {
+TEST_CASE_METHOD(TApp, "UnnamedSubNoExtras", "[subcom]") {
double val{0.0}, val2{0.0};
app.add_option("-t", val2);
auto sub = app.add_subcommand();
sub->add_option("-v,--value", val);
args = {"-t", "5.93", "-v", "-3"};
run();
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
- EXPECT_EQ(app.remaining_size(), 0u);
- EXPECT_EQ(sub->remaining_size(), 0u);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
+ CHECK(0u == app.remaining_size());
+ CHECK(0u == sub->remaining_size());
}
-TEST_F(TApp, SubcommandAlias) {
+TEST_CASE_METHOD(TApp, "SubcommandAlias", "[subcom]") {
double val{0.0};
auto sub = app.add_subcommand("sub1");
sub->alias("sub2");
@@ -1552,27 +1548,27 @@ TEST_F(TApp, SubcommandAlias) {
sub->add_option("-v,--value", val);
args = {"sub1", "-v", "-3"};
run();
- EXPECT_EQ(val, -3.0);
+ CHECK(-3.0 == val);
args = {"sub2", "--value", "-5"};
run();
- EXPECT_EQ(val, -5.0);
+ CHECK(-5.0 == val);
args = {"sub3", "-v", "7"};
run();
- EXPECT_EQ(val, 7);
+ CHECK(7 == val);
auto &al = sub->get_aliases();
- ASSERT_GE(al.size(), 2U);
+ REQUIRE(2U <= al.size());
- EXPECT_EQ(al[0], "sub2");
- EXPECT_EQ(al[1], "sub3");
+ CHECK("sub2" == al[0]);
+ CHECK("sub3" == al[1]);
sub->clear_aliases();
- EXPECT_TRUE(al.empty());
+ CHECK(al.empty());
}
-TEST_F(TApp, SubcommandAliasIgnoreCaseUnderscore) {
+TEST_CASE_METHOD(TApp, "SubcommandAliasIgnoreCaseUnderscore", "[subcom]") {
double val{0.0};
auto sub = app.add_subcommand("sub1");
sub->alias("sub2");
@@ -1581,63 +1577,63 @@ TEST_F(TApp, SubcommandAliasIgnoreCaseUnderscore) {
sub->add_option("-v,--value", val);
args = {"sub1", "-v", "-3"};
run();
- EXPECT_EQ(val, -3.0);
+ CHECK(-3.0 == val);
args = {"SUB2", "--value", "-5"};
run();
- EXPECT_EQ(val, -5.0);
+ CHECK(-5.0 == val);
args = {"sUb3", "-v", "7"};
run();
- EXPECT_EQ(val, 7);
+ CHECK(7 == val);
sub->ignore_underscore();
args = {"sub_1", "-v", "-3"};
run();
- EXPECT_EQ(val, -3.0);
+ CHECK(-3.0 == val);
args = {"SUB_2", "--value", "-5"};
run();
- EXPECT_EQ(val, -5.0);
+ CHECK(-5.0 == val);
args = {"sUb_3", "-v", "7"};
run();
- EXPECT_EQ(val, 7);
+ CHECK(7 == val);
sub->ignore_case(false);
args = {"sub_1", "-v", "-3"};
run();
- EXPECT_EQ(val, -3.0);
+ CHECK(-3.0 == val);
args = {"SUB_2", "--value", "-5"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"sUb_3", "-v", "7"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
}
-TEST_F(TApp, OptionGroupAlias) {
+TEST_CASE_METHOD(TApp, "OptionGroupAlias", "[subcom]") {
double val{0.0};
auto sub = app.add_option_group("sub1");
sub->alias("sub2");
sub->alias("sub3");
sub->add_option("-v,--value", val);
args = {"sub1", "-v", "-3"};
- EXPECT_THROW(run(), CLI::ExtrasError);
+ CHECK_THROWS_AS(run(), CLI::ExtrasError);
args = {"sub2", "--value", "-5"};
run();
- EXPECT_EQ(val, -5.0);
+ CHECK(-5.0 == val);
args = {"sub3", "-v", "7"};
run();
- EXPECT_EQ(val, 7);
+ CHECK(7 == val);
args = {"-v", "-3"};
run();
- EXPECT_EQ(val, -3);
+ CHECK(-3 == val);
}
-TEST_F(TApp, subcommand_help) {
+TEST_CASE_METHOD(TApp, "subcommand_help", "[subcom]") {
auto sub1 = app.add_subcommand("help")->silent();
bool flag{false};
app.add_flag("--one", flag, "FLAGGER");
@@ -1650,52 +1646,52 @@ TEST_F(TApp, subcommand_help) {
called = true;
}
auto helpstr = app.help();
- EXPECT_THAT(helpstr, HasSubstr("FLAGGER"));
- EXPECT_TRUE(called);
+ CHECK_THAT(helpstr, Contains("FLAGGER"));
+ CHECK(called);
}
-TEST_F(TApp, AliasErrors) {
+TEST_CASE_METHOD(TApp, "AliasErrors", "[subcom]") {
auto sub1 = app.add_subcommand("sub1");
auto sub2 = app.add_subcommand("sub2");
- EXPECT_THROW(sub2->alias("this is a not a valid alias"), CLI::IncorrectConstruction);
- EXPECT_THROW(sub2->alias("-alias"), CLI::IncorrectConstruction);
- EXPECT_THROW(sub2->alias("alia$"), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(sub2->alias("this is a not a valid alias"), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(sub2->alias("-alias"), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(sub2->alias("alia$"), CLI::IncorrectConstruction);
- EXPECT_THROW(app.add_subcommand("--bad_subcommand_name", "documenting the bad subcommand"),
- CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_subcommand("--bad_subcommand_name", "documenting the bad subcommand"),
+ CLI::IncorrectConstruction);
- EXPECT_THROW(app.add_subcommand("documenting a subcommand", "sub3"), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app.add_subcommand("documenting a subcommand", "sub3"), CLI::IncorrectConstruction);
// cannot alias to an existing subcommand
- EXPECT_THROW(sub2->alias("sub1"), CLI::OptionAlreadyAdded);
- EXPECT_THROW(sub1->alias("sub2"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->alias("sub1"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub1->alias("sub2"), CLI::OptionAlreadyAdded);
// aliasing to an existing name should be allowed
- EXPECT_NO_THROW(sub1->alias(sub1->get_name()));
+ CHECK_NOTHROW(sub1->alias(sub1->get_name()));
sub1->alias("les1")->alias("les2")->alias("les_3");
sub2->alias("s2les1")->alias("s2les2")->alias("s2les3");
- EXPECT_THROW(sub2->alias("les2"), CLI::OptionAlreadyAdded);
- EXPECT_THROW(sub1->alias("s2les2"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->alias("les2"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub1->alias("s2les2"), CLI::OptionAlreadyAdded);
- EXPECT_THROW(sub2->name("sub1"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->name("sub1"), CLI::OptionAlreadyAdded);
sub2->ignore_underscore();
- EXPECT_THROW(sub2->alias("les3"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->alias("les3"), CLI::OptionAlreadyAdded);
}
// test adding a subcommand via the pointer
-TEST_F(TApp, ExistingSubcommandMatch) {
+TEST_CASE_METHOD(TApp, "ExistingSubcommandMatch", "[subcom]") {
auto sshared = std::make_shared<CLI::App>("documenting the subcommand", "sub1");
sshared->alias("sub2")->alias("sub3");
- EXPECT_EQ(sshared->get_name(), "sub1");
+ CHECK("sub1" == sshared->get_name());
app.add_subcommand("sub1");
try {
app.add_subcommand(sshared);
// this should throw the next line should never be reached
- EXPECT_FALSE(true);
+ CHECK(!true);
} catch(const CLI::OptionAlreadyAdded &oaa) {
- EXPECT_THAT(oaa.what(), HasSubstr("sub1"));
+ CHECK_THAT(oaa.what(), Contains("sub1"));
}
sshared->name("osub");
app.add_subcommand("sub2");
@@ -1703,35 +1699,35 @@ TEST_F(TApp, ExistingSubcommandMatch) {
try {
app.add_subcommand(sshared);
// this should throw the next line should never be reached
- EXPECT_FALSE(true);
+ CHECK(!true);
} catch(const CLI::OptionAlreadyAdded &oaa) {
- EXPECT_THAT(oaa.what(), HasSubstr("sub2"));
+ CHECK_THAT(oaa.what(), Contains("sub2"));
}
// now check that disabled subcommands can be added regardless of name
sshared->name("sub1");
sshared->disabled();
- EXPECT_NO_THROW(app.add_subcommand(sshared));
+ CHECK_NOTHROW(app.add_subcommand(sshared));
}
-TEST_F(TApp, AliasErrorsInOptionGroup) {
+TEST_CASE_METHOD(TApp, "AliasErrorsInOptionGroup", "[subcom]") {
auto sub1 = app.add_subcommand("sub1");
auto g2 = app.add_option_group("g1");
auto sub2 = g2->add_subcommand("sub2");
// cannot alias to an existing subcommand even if it is in an option group
- EXPECT_THROW(sub2->alias("sub1"), CLI::OptionAlreadyAdded);
- EXPECT_THROW(sub1->alias("sub2"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->alias("sub1"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub1->alias("sub2"), CLI::OptionAlreadyAdded);
sub1->alias("les1")->alias("les2")->alias("les3");
sub2->alias("s2les1")->alias("s2les2")->alias("s2les3");
- EXPECT_THROW(sub2->alias("les2"), CLI::OptionAlreadyAdded);
- EXPECT_THROW(sub1->alias("s2les2"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->alias("les2"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub1->alias("s2les2"), CLI::OptionAlreadyAdded);
- EXPECT_THROW(sub2->name("sub1"), CLI::OptionAlreadyAdded);
+ CHECK_THROWS_AS(sub2->name("sub1"), CLI::OptionAlreadyAdded);
}
-TEST(SharedSubTests, SharedSubcommand) {
+TEST_CASE("SharedSubTests: SharedSubcommand", "[subcom]") {
double val{0.0}, val2{0.0}, val3{0.0}, val4{0.0};
CLI::App app1{"test program1"};
@@ -1745,7 +1741,7 @@ TEST(SharedSubTests, SharedSubcommand) {
auto subown = app1.get_subcommand_ptr(sub);
// add the extracted subcommand to a different app
app2.add_subcommand(std::move(subown));
- EXPECT_THROW(app2.add_subcommand(CLI::App_p{}), CLI::IncorrectConstruction);
+ CHECK_THROWS_AS(app2.add_subcommand(CLI::App_p{}), CLI::IncorrectConstruction);
input_t args1 = {"-m", "4.56", "-t", "5.93", "-v", "-3"};
input_t args2 = {"-m", "4.56", "-g", "8.235"};
std::reverse(std::begin(args1), std::end(args1));
@@ -1755,13 +1751,13 @@ TEST(SharedSubTests, SharedSubcommand) {
app2.parse(args2);
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
- EXPECT_EQ(val3, 4.56);
- EXPECT_EQ(val4, 8.235);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
+ CHECK(4.56 == val3);
+ CHECK(8.235 == val4);
}
-TEST(SharedSubTests, SharedSubIndependent) {
+TEST_CASE("SharedSubTests: SharedSubIndependent", "[subcom]") {
double val{0.0}, val2{0.0}, val4{0.0};
CLI::App_p app1 = std::make_shared<CLI::App>("test program1");
app1->allow_extras();
@@ -1784,12 +1780,12 @@ TEST(SharedSubTests, SharedSubIndependent) {
// parse with the extracted subcommand
subown->parse(args2);
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
- EXPECT_EQ(val4, 8.235);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
+ CHECK(8.235 == val4);
}
-TEST(SharedSubTests, SharedSubIndependentReuse) {
+TEST_CASE("SharedSubTests: SharedSubIndependentReuse", "[subcom]") {
double val{0.0}, val2{0.0}, val4{0.0};
CLI::App_p app1 = std::make_shared<CLI::App>("test program1");
app1->allow_extras();
@@ -1809,60 +1805,60 @@ TEST(SharedSubTests, SharedSubIndependentReuse) {
// parse with the extracted subcommand
subown->parse("program1 -m 4.56 -g 8.235", true);
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
- EXPECT_EQ(val4, 8.235);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
+ CHECK(8.235 == val4);
val = 0.0;
val2 = 0.0;
- EXPECT_EQ(subown->get_name(), "program1");
+ CHECK("program1" == subown->get_name());
// this tests the name reset in subcommand since it was automatic
app1->parse(args2);
- EXPECT_EQ(val, -3.0);
- EXPECT_EQ(val2, 5.93);
+ CHECK(-3.0 == val);
+ CHECK(5.93 == val2);
}
-TEST_F(ManySubcommands, getSubtests) {
+TEST_CASE_METHOD(ManySubcommands, "getSubtests", "[subcom]") {
CLI::App_p sub2p = app.get_subcommand_ptr(sub2);
- EXPECT_EQ(sub2p.get(), sub2);
- EXPECT_THROW(app.get_subcommand_ptr(nullptr), CLI::OptionNotFound);
- EXPECT_THROW(app.get_subcommand(nullptr), CLI::OptionNotFound);
+ CHECK(sub2 == sub2p.get());
+ CHECK_THROWS_AS(app.get_subcommand_ptr(nullptr), CLI::OptionNotFound);
+ CHECK_THROWS_AS(app.get_subcommand(nullptr), CLI::OptionNotFound);
CLI::App_p sub3p = app.get_subcommand_ptr(2);
- EXPECT_EQ(sub3p.get(), sub3);
+ CHECK(sub3 == sub3p.get());
}
-TEST_F(ManySubcommands, defaultDisabledSubcommand) {
+TEST_CASE_METHOD(ManySubcommands, "defaultDisabledSubcommand", "[subcom]") {
sub1->fallthrough();
sub2->disabled_by_default();
run();
auto rem = app.remaining();
- EXPECT_EQ(rem.size(), 1u);
- EXPECT_EQ(rem[0], "sub2");
- EXPECT_TRUE(sub2->get_disabled_by_default());
+ CHECK(1u == rem.size());
+ CHECK("sub2" == rem[0]);
+ CHECK(sub2->get_disabled_by_default());
sub2->disabled(false);
- EXPECT_FALSE(sub2->get_disabled());
+ CHECK(!sub2->get_disabled());
run();
// this should disable it again even though it was disabled
rem = app.remaining();
- EXPECT_EQ(rem.size(), 1u);
- EXPECT_EQ(rem[0], "sub2");
- EXPECT_TRUE(sub2->get_disabled_by_default());
- EXPECT_TRUE(sub2->get_disabled());
+ CHECK(1u == rem.size());
+ CHECK("sub2" == rem[0]);
+ CHECK(sub2->get_disabled_by_default());
+ CHECK(sub2->get_disabled());
}
-TEST_F(ManySubcommands, defaultEnabledSubcommand) {
+TEST_CASE_METHOD(ManySubcommands, "defaultEnabledSubcommand", "[subcom]") {
sub2->enabled_by_default();
run();
auto rem = app.remaining();
- EXPECT_EQ(rem.size(), 0u);
- EXPECT_TRUE(sub2->get_enabled_by_default());
+ CHECK(0u == rem.size());
+ CHECK(sub2->get_enabled_by_default());
sub2->disabled();
- EXPECT_TRUE(sub2->get_disabled());
+ CHECK(sub2->get_disabled());
run();
// this should disable it again even though it was disabled
rem = app.remaining();
- EXPECT_EQ(rem.size(), 0u);
- EXPECT_TRUE(sub2->get_enabled_by_default());
- EXPECT_FALSE(sub2->get_disabled());
+ CHECK(0u == rem.size());
+ CHECK(sub2->get_enabled_by_default());
+ CHECK(!sub2->get_disabled());
}
diff --git a/packages/CLI11/tests/TimerTest.cpp b/packages/CLI11/tests/TimerTest.cpp
index 51d8bb09b50c79b79ff62a37224ef79253c4dbed..8c88f478ace08a3e192c0439717ec44ad32b9ab9 100644
--- a/packages/CLI11/tests/TimerTest.cpp
+++ b/packages/CLI11/tests/TimerTest.cpp
@@ -5,66 +5,66 @@
// SPDX-License-Identifier: BSD-3-Clause
#include "CLI/Timer.hpp"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
+
+#include "catch.hpp"
#include <chrono>
#include <sstream>
#include <string>
#include <thread>
-using ::testing::HasSubstr;
+using Catch::Matchers::Contains;
-TEST(Timer, MSTimes) {
+TEST_CASE("Timer: MSTimes", "[timer]") {
CLI::Timer timer{"My Timer"};
std::this_thread::sleep_for(std::chrono::milliseconds(123));
std::string output = timer.to_string();
std::string new_output = (timer / 1000000).to_string();
- EXPECT_THAT(output, HasSubstr("My Timer"));
- EXPECT_THAT(output, HasSubstr(" ms"));
- EXPECT_THAT(new_output, HasSubstr(" ns"));
+ CHECK_THAT(output, Contains("My Timer"));
+ CHECK_THAT(output, Contains(" ms"));
+ CHECK_THAT(new_output, Contains(" ns"));
}
/* Takes too long
-TEST(Timer, STimes) {
+TEST_CASE("Timer: STimes", "[timer]") {
CLI::Timer timer;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::string output = timer.to_string();
- EXPECT_THAT(output, HasSubstr(" s"));
+ CHECK_THAT (output, Contains(" s"));
}
*/
// Fails on Windows
-// TEST(Timer, UStimes) {
+// TEST_CASE("Timer: UStimes", "[timer]") {
// CLI::Timer timer;
// std::this_thread::sleep_for(std::chrono::microseconds(2));
// std::string output = timer.to_string();
-// EXPECT_THAT(output, HasSubstr(" ms"));
+// CHECK_THAT (output, Contains(" ms"));
//}
-TEST(Timer, BigTimer) {
+TEST_CASE("Timer: BigTimer", "[timer]") {
CLI::Timer timer{"My Timer", CLI::Timer::Big};
std::string output = timer.to_string();
- EXPECT_THAT(output, HasSubstr("Time ="));
- EXPECT_THAT(output, HasSubstr("-----------"));
+ CHECK_THAT(output, Contains("Time ="));
+ CHECK_THAT(output, Contains("-----------"));
}
-TEST(Timer, AutoTimer) {
+TEST_CASE("Timer: AutoTimer", "[timer]") {
CLI::AutoTimer timer;
std::string output = timer.to_string();
- EXPECT_THAT(output, HasSubstr("Timer"));
+ CHECK_THAT(output, Contains("Timer"));
}
-TEST(Timer, PrintTimer) {
+TEST_CASE("Timer: PrintTimer", "[timer]") {
std::stringstream out;
CLI::AutoTimer timer;
out << timer;
std::string output = out.str();
- EXPECT_THAT(output, HasSubstr("Timer"));
+ CHECK_THAT(output, Contains("Timer"));
}
-TEST(Timer, TimeItTimer) {
+TEST_CASE("Timer: TimeItTimer", "[timer]") {
CLI::Timer timer;
std::string output = timer.time_it([]() { std::this_thread::sleep_for(std::chrono::milliseconds(10)); }, .1);
std::cout << output << std::endl;
- EXPECT_THAT(output, HasSubstr("ms"));
+ CHECK_THAT(output, Contains("ms"));
}
diff --git a/packages/CLI11/tests/TransformTest.cpp b/packages/CLI11/tests/TransformTest.cpp
index 53df504acadf14e91cfb7b58bde88917593664b9..84ac544a4d003778cbcd73797034eb70c5612d98 100644
--- a/packages/CLI11/tests/TransformTest.cpp
+++ b/packages/CLI11/tests/TransformTest.cpp
@@ -20,98 +20,98 @@
#endif
#endif
-TEST_F(TApp, SimpleTransform) {
+TEST_CASE_METHOD(TApp, "SimpleTransform", "[transform]") {
int value{0};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer({{"one", std::string("1")}}));
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
-TEST_F(TApp, SimpleTransformInitList) {
+TEST_CASE_METHOD(TApp, "SimpleTransformInitList", "[transform]") {
int value{0};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer({{"one", "1"}}));
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
-TEST_F(TApp, SimpleNumericalTransform) {
+TEST_CASE_METHOD(TApp, "SimpleNumericalTransform", "[transform]") {
int value{0};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(CLI::TransformPairs<int>{{"one", 1}}));
args = {"-s", "one"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
-TEST_F(TApp, EnumTransform) {
- enum class test : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
- test value{test::val2};
+TEST_CASE_METHOD(TApp, "EnumTransform", "[transform]") {
+ enum class test_cli : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
+ test_cli value{test_cli::val2};
auto opt = app.add_option("-s", value)
- ->transform(CLI::Transformer(
- CLI::TransformPairs<test>{{"val1", test::val1}, {"val2", test::val2}, {"val3", test::val3}}));
+ ->transform(CLI::Transformer(CLI::TransformPairs<test_cli>{
+ {"val1", test_cli::val1}, {"val2", test_cli::val2}, {"val3", test_cli::val3}}));
args = {"-s", "val1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, test::val1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(test_cli::val1 == value);
args = {"-s", "val2"};
run();
- EXPECT_EQ(value, test::val2);
+ CHECK(test_cli::val2 == value);
args = {"-s", "val3"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "val4"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
// transformer doesn't do any checking so this still works
args = {"-s", "5"};
run();
- EXPECT_EQ(static_cast<std::int16_t>(value), std::int16_t(5));
+ CHECK(std::int16_t(5) == static_cast<std::int16_t>(value));
}
-TEST_F(TApp, EnumCheckedTransform) {
- enum class test : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
- test value{test::val1};
+TEST_CASE_METHOD(TApp, "EnumCheckedTransform", "[transform]") {
+ enum class test_cli : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
+ test_cli value{test_cli::val1};
auto opt = app.add_option("-s", value)
- ->transform(CLI::CheckedTransformer(
- CLI::TransformPairs<test>{{"val1", test::val1}, {"val2", test::val2}, {"val3", test::val3}}));
+ ->transform(CLI::CheckedTransformer(CLI::TransformPairs<test_cli>{
+ {"val1", test_cli::val1}, {"val2", test_cli::val2}, {"val3", test_cli::val3}}));
args = {"-s", "val1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, test::val1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(test_cli::val1 == value);
args = {"-s", "val2"};
run();
- EXPECT_EQ(value, test::val2);
+ CHECK(test_cli::val2 == value);
args = {"-s", "val3"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "17"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "val4"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-s", "5"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
// from jzakrzewski Issue #330
-TEST_F(TApp, EnumCheckedDefaultTransform) {
+TEST_CASE_METHOD(TApp, "EnumCheckedDefaultTransform", "[transform]") {
enum class existing : std::int16_t { abort, overwrite, remove };
app.add_option("--existing", "What to do if file already exists in the destination")
->transform(
@@ -122,14 +122,14 @@ TEST_F(TApp, EnumCheckedDefaultTransform) {
->default_val("abort");
args = {"--existing", "overwrite"};
run();
- EXPECT_EQ(app.get_option("--existing")->as<existing>(), existing::overwrite);
+ CHECK(existing::overwrite == app.get_option("--existing")->as<existing>());
args.clear();
run();
- EXPECT_EQ(app.get_option("--existing")->as<existing>(), existing::abort);
+ CHECK(existing::abort == app.get_option("--existing")->as<existing>());
}
// test from https://github.com/CLIUtils/CLI11/issues/369 [Jakub Zakrzewski](https://github.com/jzakrzewski)
-TEST_F(TApp, EnumCheckedDefaultTransformCallback) {
+TEST_CASE_METHOD(TApp, "EnumCheckedDefaultTransformCallback", "[transform]") {
enum class existing : std::int16_t { abort, overwrite, remove };
auto cmd = std::make_shared<CLI::App>("deploys the repository somewhere", "deploy");
cmd->add_option("--existing", "What to do if file already exists in the destination")
@@ -140,60 +140,60 @@ TEST_F(TApp, EnumCheckedDefaultTransformCallback) {
{"remove", existing::remove}}))
->default_val("abort");
- cmd->callback([cmd]() { EXPECT_EQ(cmd->get_option("--existing")->as<existing>(), existing::abort); });
+ cmd->callback([cmd]() { CHECK(cmd->get_option("--existing")->as<existing>() == existing::abort); });
app.add_subcommand(cmd);
args = {"deploy"};
run();
}
-TEST_F(TApp, SimpleTransformFn) {
+TEST_CASE_METHOD(TApp, "SimpleTransformFn", "[transform]") {
int value{0};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer({{"one", "1"}}, CLI::ignore_case));
args = {"-s", "ONE"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
#if defined(CLI11_HAS_STRING_VIEW)
-TEST_F(TApp, StringViewTransformFn) {
+TEST_CASE_METHOD(TApp, "StringViewTransformFn", "[transform]") {
std::string value;
std::map<std::string_view, std::string_view> map = {// key length > std::string().capacity() [SSO length]
{"a-rather-long-argument", "mapped"}};
app.add_option("-s", value)->transform(CLI::CheckedTransformer(map));
args = {"-s", "a-rather-long-argument"};
run();
- EXPECT_EQ(value, "mapped");
+ CHECK("mapped" == value);
}
#endif
-TEST_F(TApp, SimpleNumericalTransformFn) {
+TEST_CASE_METHOD(TApp, "SimpleNumericalTransformFn", "[transform]") {
int value{0};
auto opt =
app.add_option("-s", value)
->transform(CLI::Transformer(std::vector<std::pair<std::string, int>>{{"one", 1}}, CLI::ignore_case));
args = {"-s", "ONe"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
-TEST_F(TApp, SimpleNumericalTransformFnVector) {
+TEST_CASE_METHOD(TApp, "SimpleNumericalTransformFnVector", "[transform]") {
std::vector<std::pair<std::string, int>> conversions{{"one", 1}, {"two", 2}};
int value{0};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(conversions, CLI::ignore_case));
args = {"-s", "ONe"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
-TEST_F(TApp, SimpleNumericalTransformFnArray) {
+TEST_CASE_METHOD(TApp, "SimpleNumericalTransformFnArray", "[transform]") {
std::array<std::pair<std::string, int>, 2> conversions;
conversions[0] = std::make_pair(std::string("one"), 1);
conversions[1] = std::make_pair(std::string("two"), 2);
@@ -202,14 +202,14 @@ TEST_F(TApp, SimpleNumericalTransformFnArray) {
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(conversions, CLI::ignore_case));
args = {"-s", "ONe"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
}
#ifdef CLI11_CPP14
// zero copy constexpr array operation with transformer example and test
-TEST_F(TApp, SimpleNumericalTransformFnconstexprArray) {
+TEST_CASE_METHOD(TApp, "SimpleNumericalTransformFnconstexprArray", "[transform]") {
constexpr std::pair<const char *, int> p1{"one", 1};
constexpr std::pair<const char *, int> p2{"two", 2};
constexpr std::array<std::pair<const char *, int>, 2> conversions_c{{p1, p2}};
@@ -218,128 +218,129 @@ TEST_F(TApp, SimpleNumericalTransformFnconstexprArray) {
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(&conversions_c, CLI::ignore_case));
args = {"-s", "ONe"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(1 == value);
args = {"-s", "twO"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, 2);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(2 == value);
}
#endif
-TEST_F(TApp, EnumTransformFn) {
- enum class test : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
- test value{test::val2};
+TEST_CASE_METHOD(TApp, "EnumTransformFn", "[transform]") {
+ enum class test_cli : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
+ test_cli value{test_cli::val2};
auto opt = app.add_option("-s", value)
- ->transform(CLI::Transformer(
- CLI::TransformPairs<test>{{"val1", test::val1}, {"val2", test::val2}, {"val3", test::val3}},
- CLI::ignore_case,
- CLI::ignore_underscore));
+ ->transform(CLI::Transformer(CLI::TransformPairs<test_cli>{{"val1", test_cli::val1},
+ {"val2", test_cli::val2},
+ {"val3", test_cli::val3}},
+ CLI::ignore_case,
+ CLI::ignore_underscore));
args = {"-s", "val_1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, test::val1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(test_cli::val1 == value);
args = {"-s", "VAL_2"};
run();
- EXPECT_EQ(value, test::val2);
+ CHECK(test_cli::val2 == value);
args = {"-s", "VAL3"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "val_4"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, EnumTransformFnMap) {
- enum class test : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
- std::map<std::string, test> map{{"val1", test::val1}, {"val2", test::val2}, {"val3", test::val3}};
- test value{test::val3};
+TEST_CASE_METHOD(TApp, "EnumTransformFnMap", "[transform]") {
+ enum class test_cli : std::int16_t { val1 = 3, val2 = 4, val3 = 17 };
+ std::map<std::string, test_cli> map{{"val1", test_cli::val1}, {"val2", test_cli::val2}, {"val3", test_cli::val3}};
+ test_cli value{test_cli::val3};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(map, CLI::ignore_case, CLI::ignore_underscore));
args = {"-s", "val_1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, test::val1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(test_cli::val1 == value);
args = {"-s", "VAL_2"};
run();
- EXPECT_EQ(value, test::val2);
+ CHECK(test_cli::val2 == value);
args = {"-s", "VAL3"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "val_4"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
}
-TEST_F(TApp, EnumTransformFnPtrMap) {
- enum class test : std::int16_t { val1 = 3, val2 = 4, val3 = 17, val4 = 37 };
- std::map<std::string, test> map{{"val1", test::val1}, {"val2", test::val2}, {"val3", test::val3}};
- test value{test::val2};
+TEST_CASE_METHOD(TApp, "EnumTransformFnPtrMap", "[transform]") {
+ enum class test_cli : std::int16_t { val1 = 3, val2 = 4, val3 = 17, val4 = 37 };
+ std::map<std::string, test_cli> map{{"val1", test_cli::val1}, {"val2", test_cli::val2}, {"val3", test_cli::val3}};
+ test_cli value{test_cli::val2};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(&map, CLI::ignore_case, CLI::ignore_underscore));
args = {"-s", "val_1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, test::val1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(test_cli::val1 == value);
args = {"-s", "VAL_2"};
run();
- EXPECT_EQ(value, test::val2);
+ CHECK(test_cli::val2 == value);
args = {"-s", "VAL3"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "val_4"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
- map["val4"] = test::val4;
+ map["val4"] = test_cli::val4;
run();
- EXPECT_EQ(value, test::val4);
+ CHECK(test_cli::val4 == value);
}
-TEST_F(TApp, EnumTransformFnSharedPtrMap) {
- enum class test : std::int16_t { val1 = 3, val2 = 4, val3 = 17, val4 = 37 };
- auto map = std::make_shared<std::unordered_map<std::string, test>>();
+TEST_CASE_METHOD(TApp, "EnumTransformFnSharedPtrMap", "[transform]") {
+ enum class test_cli : std::int16_t { val1 = 3, val2 = 4, val3 = 17, val4 = 37 };
+ auto map = std::make_shared<std::unordered_map<std::string, test_cli>>();
auto &mp = *map;
- mp["val1"] = test::val1;
- mp["val2"] = test::val2;
- mp["val3"] = test::val3;
+ mp["val1"] = test_cli::val1;
+ mp["val2"] = test_cli::val2;
+ mp["val3"] = test_cli::val3;
- test value{test::val2};
+ test_cli value{test_cli::val2};
auto opt = app.add_option("-s", value)->transform(CLI::Transformer(map, CLI::ignore_case, CLI::ignore_underscore));
args = {"-s", "val_1"};
run();
- EXPECT_EQ(1u, app.count("-s"));
- EXPECT_EQ(1u, opt->count());
- EXPECT_EQ(value, test::val1);
+ CHECK(app.count("-s") == 1u);
+ CHECK(opt->count() == 1u);
+ CHECK(test_cli::val1 == value);
args = {"-s", "VAL_2"};
run();
- EXPECT_EQ(value, test::val2);
+ CHECK(test_cli::val2 == value);
args = {"-s", "VAL3"};
run();
- EXPECT_EQ(value, test::val3);
+ CHECK(test_cli::val3 == value);
args = {"-s", "val_4"};
- EXPECT_THROW(run(), CLI::ConversionError);
+ CHECK_THROWS_AS(run(), CLI::ConversionError);
- mp["val4"] = test::val4;
+ mp["val4"] = test_cli::val4;
run();
- EXPECT_EQ(value, test::val4);
+ CHECK(test_cli::val4 == value);
}
// Test a cascade of transform functions
-TEST_F(TApp, TransformCascade) {
+TEST_CASE_METHOD(TApp, "TransformCascade", "[transform]") {
std::string output;
auto opt = app.add_option("-s", output);
@@ -350,23 +351,23 @@ TEST_F(TApp, TransformCascade) {
opt->check(CLI::IsMember({"abcd", "bbcd", "cbcd"}));
args = {"-s", "abcd"};
run();
- EXPECT_EQ(output, "abcd");
+ CHECK("abcd" == output);
args = {"-s", "Bbc"};
run();
- EXPECT_EQ(output, "bbcd");
+ CHECK("bbcd" == output);
args = {"-s", "C_B"};
run();
- EXPECT_EQ(output, "cbcd");
+ CHECK("cbcd" == output);
args = {"-s", "A"};
run();
- EXPECT_EQ(output, "abcd");
+ CHECK("abcd" == output);
}
// Test a cascade of transform functions
-TEST_F(TApp, TransformCascadeDeactivate) {
+TEST_CASE_METHOD(TApp, "TransformCascadeDeactivate", "[transform]") {
std::string output;
auto opt = app.add_option("-s", output);
@@ -380,70 +381,70 @@ TEST_F(TApp, TransformCascadeDeactivate) {
opt->check(CLI::IsMember({"abcd", "bbcd", "cbcd"}).name("check"));
args = {"-s", "abcd"};
run();
- EXPECT_EQ(output, "abcd");
+ CHECK("abcd" == output);
args = {"-s", "Bbc"};
run();
- EXPECT_EQ(output, "bbcd");
+ CHECK("bbcd" == output);
args = {"-s", "C_B"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
auto validator = opt->get_validator("tform2");
- EXPECT_FALSE(validator->get_active());
- EXPECT_EQ(validator->get_name(), "tform2");
+ CHECK(!validator->get_active());
+ CHECK("tform2" == validator->get_name());
validator->active();
- EXPECT_TRUE(validator->get_active());
+ CHECK(validator->get_active());
args = {"-s", "C_B"};
run();
- EXPECT_EQ(output, "cbcd");
+ CHECK("cbcd" == output);
opt->get_validator("check")->active(false);
args = {"-s", "gsdgsgs"};
run();
- EXPECT_EQ(output, "gsdgsgs");
+ CHECK("gsdgsgs" == output);
- EXPECT_THROW(opt->get_validator("sdfsdf"), CLI::OptionNotFound);
+ CHECK_THROWS_AS(opt->get_validator("sdfsdf"), CLI::OptionNotFound);
}
-TEST_F(TApp, IntTransformFn) {
+TEST_CASE_METHOD(TApp, "IntTransformFn", "[transform]") {
std::string value;
app.add_option("-s", value)
->transform(
CLI::CheckedTransformer(std::map<int, int>{{15, 5}, {18, 6}, {21, 7}}, [](int in) { return in - 10; }));
args = {"-s", "25"};
run();
- EXPECT_EQ(value, "5");
+ CHECK("5" == value);
args = {"-s", "6"};
run();
- EXPECT_EQ(value, "6");
+ CHECK("6" == value);
args = {"-s", "45"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-s", "val_4"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, IntTransformNonConvertible) {
+TEST_CASE_METHOD(TApp, "IntTransformNonConvertible", "[transform]") {
std::string value;
app.add_option("-s", value)->transform(CLI::Transformer(std::map<int, int>{{15, 5}, {18, 6}, {21, 7}}));
args = {"-s", "15"};
run();
- EXPECT_EQ(value, "5");
+ CHECK("5" == value);
args = {"-s", "18"};
run();
- EXPECT_EQ(value, "6");
+ CHECK("6" == value);
// value can't be converted to int so it is just ignored
args = {"-s", "abcd"};
run();
- EXPECT_EQ(value, "abcd");
+ CHECK("abcd" == value);
}
-TEST_F(TApp, IntTransformNonMerge) {
+TEST_CASE_METHOD(TApp, "IntTransformNonMerge", "[transform]") {
std::string value;
app.add_option("-s", value)
->transform(CLI::Transformer(std::map<int, int>{{15, 5}, {18, 6}, {21, 7}}) &
@@ -451,39 +452,39 @@ TEST_F(TApp, IntTransformNonMerge) {
"merge");
args = {"-s", "15"};
run();
- EXPECT_EQ(value, "5");
+ CHECK("5" == value);
args = {"-s", "18"};
run();
- EXPECT_EQ(value, "6");
+ CHECK("6" == value);
// value can't be converted to int so it is just ignored
args = {"-s", "abcd"};
run();
- EXPECT_EQ(value, "abcd");
+ CHECK("abcd" == value);
args = {"-s", "25"};
run();
- EXPECT_EQ(value, "5");
+ CHECK("5" == value);
args = {"-s", "31"};
run();
- EXPECT_EQ(value, "7");
+ CHECK("7" == value);
auto help = app.help();
- EXPECT_TRUE(help.find("15->5") != std::string::npos);
- EXPECT_TRUE(help.find("25->5") != std::string::npos);
+ CHECK(help.find("15->5") != std::string::npos);
+ CHECK(help.find("25->5") != std::string::npos);
auto validator = app.get_option("-s")->get_validator();
help = validator->get_description();
- EXPECT_TRUE(help.find("15->5") != std::string::npos);
- EXPECT_TRUE(help.find("25->5") != std::string::npos);
+ CHECK(help.find("15->5") != std::string::npos);
+ CHECK(help.find("25->5") != std::string::npos);
auto validator2 = app.get_option("-s")->get_validator("merge");
- EXPECT_EQ(validator2, validator);
+ CHECK(validator == validator2);
}
-TEST_F(TApp, IntTransformMergeWithCustomValidator) {
+TEST_CASE_METHOD(TApp, "IntTransformMergeWithCustomValidator", "[transform]") {
std::string value;
auto opt = app.add_option("-s", value)
->transform(CLI::Transformer(std::map<int, int>{{15, 5}, {18, 6}, {21, 7}}) |
@@ -498,57 +499,57 @@ TEST_F(TApp, IntTransformMergeWithCustomValidator) {
"check");
args = {"-s", "15"};
run();
- EXPECT_EQ(value, "5");
+ CHECK("5" == value);
args = {"-s", "18"};
run();
- EXPECT_EQ(value, "6");
+ CHECK("6" == value);
// value can't be converted to int so it is just ignored
args = {"-s", "frog"};
run();
- EXPECT_EQ(value, "hops");
+ CHECK("hops" == value);
args = {"-s", "25"};
run();
- EXPECT_EQ(value, "25");
+ CHECK("25" == value);
auto help = app.help();
- EXPECT_TRUE(help.find("15->5") != std::string::npos);
- EXPECT_TRUE(help.find("OR") == std::string::npos);
+ CHECK(help.find("15->5") != std::string::npos);
+ CHECK(help.find("OR") == std::string::npos);
auto validator = opt->get_validator("check");
- EXPECT_EQ(validator->get_name(), "check");
+ CHECK("check" == validator->get_name());
validator->active(false);
help = app.help();
- EXPECT_TRUE(help.find("15->5") == std::string::npos);
+ CHECK(help.find("15->5") == std::string::npos);
}
-TEST_F(TApp, BoundTests) {
+TEST_CASE_METHOD(TApp, "BoundTests", "[transform]") {
double value;
app.add_option("-s", value)->transform(CLI::Bound(3.4, 5.9));
args = {"-s", "15"};
run();
- EXPECT_EQ(value, 5.9);
+ CHECK(5.9 == value);
args = {"-s", "3.689"};
run();
- EXPECT_EQ(value, std::stod("3.689"));
+ CHECK(std::stod("3.689") == value);
// value can't be converted to int so it is just ignored
args = {"-s", "abcd"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-s", "2.5"};
run();
- EXPECT_EQ(value, 3.4);
+ CHECK(3.4 == value);
auto help = app.help();
- EXPECT_TRUE(help.find("bounded to") != std::string::npos);
- EXPECT_TRUE(help.find("[3.4 - 5.9]") != std::string::npos);
+ CHECK(help.find("bounded to") != std::string::npos);
+ CHECK(help.find("[3.4 - 5.9]") != std::string::npos);
}
-TEST_F(TApp, NumberWithUnitCorrectlySplitNumber) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitCorrectlySplitNumber", "[transform]") {
std::map<std::string, int> mapping{{"a", 10}, {"b", 100}, {"cc", 1000}};
int value = 0;
@@ -556,43 +557,43 @@ TEST_F(TApp, NumberWithUnitCorrectlySplitNumber) {
args = {"-n", "42"};
run();
- EXPECT_EQ(value, 42);
+ CHECK(42 == value);
args = {"-n", "42a"};
run();
- EXPECT_EQ(value, 420);
+ CHECK(420 == value);
args = {"-n", " 42 cc "};
run();
- EXPECT_EQ(value, 42000);
+ CHECK(42000 == value);
args = {"-n", " -42 cc "};
run();
- EXPECT_EQ(value, -42000);
+ CHECK(-42000 == value);
}
-TEST_F(TApp, NumberWithUnitFloatTest) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitFloatTest", "[transform]") {
std::map<std::string, double> mapping{{"a", 10}, {"b", 100}, {"cc", 1000}};
double value{0.0};
app.add_option("-n", value)->transform(CLI::AsNumberWithUnit(mapping));
args = {"-n", "42"};
run();
- EXPECT_DOUBLE_EQ(value, 42);
+ CHECK(42 == Approx(value));
args = {"-n", ".5"};
run();
- EXPECT_DOUBLE_EQ(value, .5);
+ CHECK(.5 == Approx(value));
args = {"-n", "42.5 a"};
run();
- EXPECT_DOUBLE_EQ(value, 425);
+ CHECK(425 == Approx(value));
args = {"-n", "42.cc"};
run();
- EXPECT_DOUBLE_EQ(value, 42000);
+ CHECK(42000 == Approx(value));
}
-TEST_F(TApp, NumberWithUnitCaseSensitive) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitCaseSensitive", "[transform]") {
std::map<std::string, int> mapping{{"a", 10}, {"A", 100}};
int value{0};
@@ -600,14 +601,14 @@ TEST_F(TApp, NumberWithUnitCaseSensitive) {
args = {"-n", "42a"};
run();
- EXPECT_EQ(value, 420);
+ CHECK(420 == value);
args = {"-n", "42A"};
run();
- EXPECT_EQ(value, 4200);
+ CHECK(4200 == value);
}
-TEST_F(TApp, NumberWithUnitCaseInsensitive) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitCaseInsensitive", "[transform]") {
std::map<std::string, int> mapping{{"a", 10}, {"B", 100}};
int value{0};
@@ -615,22 +616,22 @@ TEST_F(TApp, NumberWithUnitCaseInsensitive) {
args = {"-n", "42a"};
run();
- EXPECT_EQ(value, 420);
+ CHECK(420 == value);
args = {"-n", "42A"};
run();
- EXPECT_EQ(value, 420);
+ CHECK(420 == value);
args = {"-n", "42b"};
run();
- EXPECT_EQ(value, 4200);
+ CHECK(4200 == value);
args = {"-n", "42B"};
run();
- EXPECT_EQ(value, 4200);
+ CHECK(4200 == value);
}
-TEST_F(TApp, NumberWithUnitMandatoryUnit) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitMandatoryUnit", "[transform]") {
std::map<std::string, int> mapping{{"a", 10}, {"A", 100}};
int value{0};
@@ -641,17 +642,17 @@ TEST_F(TApp, NumberWithUnitMandatoryUnit) {
args = {"-n", "42a"};
run();
- EXPECT_EQ(value, 420);
+ CHECK(420 == value);
args = {"-n", "42A"};
run();
- EXPECT_EQ(value, 4200);
+ CHECK(4200 == value);
args = {"-n", "42"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, NumberWithUnitMandatoryUnit2) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitMandatoryUnit2", "[transform]") {
std::map<std::string, int> mapping{{"a", 10}, {"B", 100}};
int value{0};
@@ -662,49 +663,49 @@ TEST_F(TApp, NumberWithUnitMandatoryUnit2) {
args = {"-n", "42A"};
run();
- EXPECT_EQ(value, 420);
+ CHECK(420 == value);
args = {"-n", "42b"};
run();
- EXPECT_EQ(value, 4200);
+ CHECK(4200 == value);
args = {"-n", "42"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, NumberWithUnitBadMapping) {
- EXPECT_THROW(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"A", 100}},
- CLI::AsNumberWithUnit::CASE_INSENSITIVE),
- CLI::ValidationError);
- EXPECT_THROW(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"9", 100}}), CLI::ValidationError);
- EXPECT_THROW(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"AA A", 100}}), CLI::ValidationError);
- EXPECT_THROW(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"", 100}}), CLI::ValidationError);
+TEST_CASE_METHOD(TApp, "NumberWithUnitBadMapping", "[transform]") {
+ CHECK_THROWS_AS(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"A", 100}},
+ CLI::AsNumberWithUnit::CASE_INSENSITIVE),
+ CLI::ValidationError);
+ CHECK_THROWS_AS(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"9", 100}}), CLI::ValidationError);
+ CHECK_THROWS_AS(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"AA A", 100}}), CLI::ValidationError);
+ CHECK_THROWS_AS(CLI::AsNumberWithUnit(std::map<std::string, int>{{"a", 10}, {"", 100}}), CLI::ValidationError);
}
-TEST_F(TApp, NumberWithUnitBadInput) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitBadInput", "[transform]") {
std::map<std::string, int> mapping{{"a", 10}, {"b", 100}};
int value{0};
app.add_option("-n", value)->transform(CLI::AsNumberWithUnit(mapping));
args = {"-n", "13 a b"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "13 c"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "a"};
// Assume 1.0 unit
- EXPECT_NO_THROW(run());
+ CHECK_NOTHROW(run());
args = {"-n", "12.0a"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "a5"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", ""};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "13 a-"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, NumberWithUnitIntOverflow) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitIntOverflow", "[transform]") {
std::map<std::string, int> mapping{{"a", 1000000}, {"b", 100}, {"c", 101}};
std::int32_t value;
@@ -712,147 +713,147 @@ TEST_F(TApp, NumberWithUnitIntOverflow) {
args = {"-n", "1000 a"};
run();
- EXPECT_EQ(value, 1000000000);
+ CHECK(1000000000 == value);
args = {"-n", "1000000 a"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "-1000000 a"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "21474836 b"};
run();
- EXPECT_EQ(value, 2147483600);
+ CHECK(2147483600 == value);
args = {"-n", "21474836 c"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
}
-TEST_F(TApp, NumberWithUnitFloatOverflow) {
+TEST_CASE_METHOD(TApp, "NumberWithUnitFloatOverflow", "[transform]") {
std::map<std::string, float> mapping{{"a", 2.f}, {"b", 1.f}, {"c", 0.f}};
float value{0.0F};
app.add_option("-n", value)->transform(CLI::AsNumberWithUnit(mapping));
args = {"-n", "3e+38 a"};
- EXPECT_THROW(run(), CLI::ValidationError);
+ CHECK_THROWS_AS(run(), CLI::ValidationError);
args = {"-n", "3e+38 b"};
run();
- EXPECT_FLOAT_EQ(value, 3e+38f);
+ CHECK(3e+38f == Approx(value));
args = {"-n", "3e+38 c"};
run();
- EXPECT_FLOAT_EQ(value, 0.f);
+ CHECK(0.f == Approx(value));
}
-TEST_F(TApp, AsSizeValue1000_1024) {
+TEST_CASE_METHOD(TApp, "AsSizeValue1000_1024", "[transform]") {
std::uint64_t value{0};
app.add_option("-s", value)->transform(CLI::AsSizeValue(true));
args = {"-s", "10240"};
run();
- EXPECT_EQ(value, 10240u);
+ CHECK(10240u == value);
args = {"-s", "1b"};
run();
- EXPECT_EQ(value, 1u);
+ CHECK(1u == value);
std::uint64_t k_value{1000u};
std::uint64_t ki_value{1024u};
args = {"-s", "1k"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1kb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1 Kb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1ki"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1kib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
k_value = 1000ull * 1000u;
ki_value = 1024ull * 1024u;
args = {"-s", "1m"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1mb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1mi"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1mib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
k_value = 1000ull * 1000u * 1000u;
ki_value = 1024ull * 1024u * 1024u;
args = {"-s", "1g"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1gb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1gi"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1gib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
k_value = 1000ull * 1000u * 1000u * 1000u;
ki_value = 1024ull * 1024u * 1024u * 1024u;
args = {"-s", "1t"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1tb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1ti"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1tib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
k_value = 1000ull * 1000u * 1000u * 1000u * 1000u;
ki_value = 1024ull * 1024u * 1024u * 1024u * 1024u;
args = {"-s", "1p"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1pb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1pi"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1pib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
k_value = 1000ull * 1000u * 1000u * 1000u * 1000u * 1000u;
ki_value = 1024ull * 1024u * 1024u * 1024u * 1024u * 1024u;
args = {"-s", "1e"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1eb"};
run();
- EXPECT_EQ(value, k_value);
+ CHECK(k_value == value);
args = {"-s", "1ei"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1eib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
}
-TEST_F(TApp, duration_test) {
+TEST_CASE_METHOD(TApp, "duration_test", "[transform]") {
std::chrono::seconds duration{1};
app.option_defaults()->ignore_case();
@@ -863,107 +864,107 @@ TEST_F(TApp, duration_test) {
->capture_default_str()
->transform(CLI::AsNumberWithUnit(
std::map<std::string, std::size_t>{{"sec", 1}, {"min", 60}, {"h", 3600}, {"day", 24 * 3600}}));
- EXPECT_NO_THROW(app.parse(std::vector<std::string>{"1 day", "--duration"}));
+ CHECK_NOTHROW(app.parse(std::vector<std::string>{"1 day", "--duration"}));
- EXPECT_EQ(duration, std::chrono::seconds(86400));
+ CHECK(std::chrono::seconds(86400) == duration);
}
-TEST_F(TApp, AsSizeValue1024) {
+TEST_CASE_METHOD(TApp, "AsSizeValue1024", "[transform]") {
std::uint64_t value{0};
app.add_option("-s", value)->transform(CLI::AsSizeValue(false));
args = {"-s", "10240"};
run();
- EXPECT_EQ(value, 10240u);
+ CHECK(10240u == value);
args = {"-s", "1b"};
run();
- EXPECT_EQ(value, 1u);
+ CHECK(1u == value);
std::uint64_t ki_value{1024u};
args = {"-s", "1k"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1kb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1 Kb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1ki"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1kib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
ki_value = 1024ull * 1024u;
args = {"-s", "1m"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1mb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1mi"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1mib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
ki_value = 1024ull * 1024u * 1024u;
args = {"-s", "1g"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1gb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1gi"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1gib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
ki_value = 1024ull * 1024u * 1024u * 1024u;
args = {"-s", "1t"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1tb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1ti"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1tib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
ki_value = 1024ull * 1024u * 1024u * 1024u * 1024u;
args = {"-s", "1p"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1pb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1pi"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1pib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
ki_value = 1024ull * 1024u * 1024u * 1024u * 1024u * 1024u;
args = {"-s", "1e"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1eb"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1ei"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
args = {"-s", "1eib"};
run();
- EXPECT_EQ(value, ki_value);
+ CHECK(ki_value == value);
}
diff --git a/packages/CLI11/tests/TrueFalseTest.cpp b/packages/CLI11/tests/TrueFalseTest.cpp
index 7c37d456dc79c9cacb409573a3ce184e02a90a8c..aa8886c092ab21c1b464ec833c3fd00924378924 100644
--- a/packages/CLI11/tests/TrueFalseTest.cpp
+++ b/packages/CLI11/tests/TrueFalseTest.cpp
@@ -6,31 +6,24 @@
#include "app_helper.hpp"
-/// This allows a set of strings to be run over by a test
-struct TApp_TBO : public TApp_base, testing::TestWithParam<const char *> {};
-
-TEST_P(TApp_TBO, TrueBoolOption) {
+TEST_CASE_METHOD(TApp, "True Bool Option", "[bool][flag]") {
+ // Strings needed here due to MSVC 2015.
+ auto param = GENERATE(as<std::string>{}, "true", "on", "True", "ON");
bool value{false}; // Not used, but set just in case
app.add_option("-b,--bool", value);
- args = {"--bool", GetParam()};
+ args = {"--bool", param};
run();
- EXPECT_EQ(1u, app.count("--bool"));
- EXPECT_TRUE(value);
+ CHECK(app.count("--bool") == 1u);
+ CHECK(value);
}
-// Change to INSTANTIATE_TEST_SUITE_P in GTest master
-INSTANTIATE_TEST_SUITE_P(TrueBoolOptions_test, TApp_TBO, testing::Values("true", "on", "True", "ON"));
-
-/// This allows a set of strings to be run over by a test
-struct TApp_FBO : public TApp_base, public ::testing::TestWithParam<const char *> {};
+TEST_CASE_METHOD(TApp, "False Bool Option", "[bool][flag]") {
+ auto param = GENERATE(as<std::string>{}, "false", "off", "False", "OFF");
-TEST_P(TApp_FBO, FalseBoolOptions) {
bool value{true}; // Not used, but set just in case
app.add_option("-b,--bool", value);
- args = {"--bool", GetParam()};
+ args = {"--bool", param};
run();
- EXPECT_EQ(1u, app.count("--bool"));
- EXPECT_FALSE(value);
+ CHECK(app.count("--bool") == 1u);
+ CHECK_FALSE(value);
}
-
-INSTANTIATE_TEST_SUITE_P(FalseBoolOptions_test, TApp_FBO, ::testing::Values("false", "off", "False", "OFF"));
diff --git a/packages/CLI11/tests/WindowsTest.cpp b/packages/CLI11/tests/WindowsTest.cpp
index 41053bbe9212c6c1f6134c9e230d22c77a04cc3f..847266649965e6fc03176cda5862d46d07dbe103 100644
--- a/packages/CLI11/tests/WindowsTest.cpp
+++ b/packages/CLI11/tests/WindowsTest.cpp
@@ -10,10 +10,10 @@
// This test verifies that CLI11 still works if
// Windows.h is included. #145
-TEST_F(TApp, WindowsTestSimple) {
+TEST_CASE_METHOD(TApp, "WindowsTestSimple", "[windows]") {
app.add_flag("-c,--count");
args = {"-c"};
run();
- EXPECT_EQ(1u, app.count("-c"));
- EXPECT_EQ(1u, app.count("--count"));
+ CHECK(app.count("-c") == 1u);
+ CHECK(app.count("--count") == 1u);
}
diff --git a/packages/CLI11/tests/app_helper.hpp b/packages/CLI11/tests/app_helper.hpp
index 6b250a422cb5f13eb549d9a5bf9d91f58f029953..0f72adda27064e17d3cb97f242526e5b1b2b4501 100644
--- a/packages/CLI11/tests/app_helper.hpp
+++ b/packages/CLI11/tests/app_helper.hpp
@@ -12,7 +12,7 @@
#include "CLI/CLI.hpp"
#endif
-#include "gtest/gtest.h"
+#include "catch.hpp"
#include <iostream>
#include <string>
#include <utility>
@@ -20,11 +20,11 @@
using input_t = std::vector<std::string>;
-class TApp_base {
+class TApp {
public:
CLI::App app{"My Test Program"};
input_t args{};
- virtual ~TApp_base() = default;
+ virtual ~TApp() = default;
void run() {
// It is okay to re-parse - clear is called automatically before a parse.
input_t newargs = args;
@@ -33,8 +33,6 @@ class TApp_base {
}
};
-class TApp : public TApp_base, public ::testing::Test {};
-
class TempFile {
std::string _name{};
diff --git a/packages/CLI11/tests/link_test_2.cpp b/packages/CLI11/tests/link_test_2.cpp
index ba4cc8fe1d01be7bce5276c8b3fcd5349afb7790..b8544ab47a8104b831b66cd409490c200261bcb7 100644
--- a/packages/CLI11/tests/link_test_2.cpp
+++ b/packages/CLI11/tests/link_test_2.cpp
@@ -6,12 +6,12 @@
#include "CLI/CLI.hpp"
#include "CLI/Timer.hpp"
-#include <gtest/gtest.h>
+#include "catch.hpp"
int do_nothing();
// Verifies there are no unguarded inlines
-TEST(Link, DoNothing) {
+TEST_CASE("Link: DoNothing", "[link]") {
int a = do_nothing();
- EXPECT_EQ(7, a);
+ CHECK(a == 7);
}
diff --git a/packages/CLI11/tests/main.cpp b/packages/CLI11/tests/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1c2725f53e260069f3cc867bb1398ac21cb4b2f
--- /dev/null
+++ b/packages/CLI11/tests/main.cpp
@@ -0,0 +1,8 @@
+// Copyright (c) 2017-2020, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"