diff --git a/.gitignore b/.gitignore
index 2a6ef59a..cc1b9d0c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,3 +12,4 @@ a.out*
 /node_modules/*
 /package.json
 /yarn.lock
+/CLI11.hpp
diff --git a/cmake/AddGoogletest.cmake b/cmake/AddGoogletest.cmake
deleted file mode 100644
index ae0dc18f..00000000
--- a/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/tests/AppTest.cpp b/tests/AppTest.cpp
index 89f52c08..f4193a18 100644
--- a/tests/AppTest.cpp
+++ b/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),
+                    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/tests/BoostOptionTypeTest.cpp b/tests/BoostOptionTypeTest.cpp
index 3ddd6ae4..2110bcc6 100644
--- a/tests/BoostOptionTypeTest.cpp
+++ b/tests/BoostOptionTypeTest.cpp
@@ -15,137 +15,112 @@
 #include <string>
 #include <vector>
 
-#include "gmock/gmock.h"
+using namespace boost::container;
 
-namespace boost {
-namespace 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);
 
-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());
+    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() {}
-};
+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>)) {
 
-TYPED_TEST_SUITE(TApp_container_container_boost, containerTypes_container_boost, );
+    TApp tapp;
+    TestType cv;
 
-TYPED_TEST(TApp_container_container_boost, containerContainer_boost) {
+    tapp.app.add_option("--dict", cv);
 
-    auto &cv = TApp_container_container_boost<TypeParam>::cval;
-    (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();
+    CHECK(2u == cv.size());
 
-    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);
+    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());
 }
-
-}  // namespace container
-}  // namespace boost
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index cce6e30b..4a86923f 100644
--- a/tests/CMakeLists.txt
+++ b/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/tests/ComplexTypeTest.cpp b/tests/ComplexTypeTest.cpp
index 43c6cd48..b9a5d4e5 100644
--- a/tests/ComplexTypeTest.cpp
+++ b/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/tests/ConfigFileTest.cpp b/tests/ConfigFileTest.cpp
index d8b19d14..12fa88c1 100644
--- a/tests/ConfigFileTest.cpp
+++ b/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));
+    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(StringBased, TomlVector) {
+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));
+    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(StringBased, Spaces) {
+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/tests/CreationTest.cpp b/tests/CreationTest.cpp
index 842455cb..2a70f70d 100644
--- a/tests/CreationTest.cpp
+++ b/tests/CreationTest.cpp
@@ -7,224 +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) {
+TEST_CASE_METHOD(TApp, "IncorrectConstructionFlagPositional1", "[creation]") {
     // This wants to be one line with clang-format
-    EXPECT_THROW(app.add_flag("cat"), CLI::IncorrectConstruction);
+    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");
@@ -233,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();
@@ -261,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();
 
@@ -288,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();
 
@@ -319,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()
@@ -410,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();
@@ -481,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);
@@ -539,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;
     };
@@ -593,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;
@@ -669,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{};
 
@@ -691,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
 }
 
@@ -734,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);
 
@@ -749,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/tests/DeprecatedTest.cpp b/tests/DeprecatedTest.cpp
index a8f41971..62d3619d 100644
--- a/tests/DeprecatedTest.cpp
+++ b/tests/DeprecatedTest.cpp
@@ -6,37 +6,34 @@
 
 #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) {
+TEST_CASE_METHOD(TApp, "SetWithDefaults", "[deprecated]") {
     int someint = 2;
     app.add_set("-a", someint, {1, 2, 3, 4}, "", true);
 
     args = {"-a1", "-a2"};
 
-    EXPECT_THROW(run(), CLI::ArgumentMismatch);
+    CHECK_THROWS_AS(run(), CLI::ArgumentMismatch);
 }
 
-TEST_F(TApp, SetWithDefaultsConversion) {
+TEST_CASE_METHOD(TApp, "SetWithDefaultsConversion", "[deprecated]") {
     int someint = 2;
     app.add_set("-a", someint, {1, 2, 3, 4}, "", true);
 
     args = {"-a", "hi"};
 
-    EXPECT_THROW(run(), CLI::ValidationError);
+    CHECK_THROWS_AS(run(), CLI::ValidationError);
 }
 
-TEST_F(TApp, InSet) {
+TEST_CASE_METHOD(TApp, "InSet", "[deprecated]") {
 
     std::string choice;
     app.add_set("-q,--quick", choice, {"one", "two", "three"});
@@ -44,30 +41,30 @@ 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", "[deprecated]") {
 
     std::string choice = "one";
     app.add_set("-q,--quick", choice, {"one", "two", "three"}, "", true);
 
     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", "[deprecated]") {
 
     int choice;
     app.add_set("-q,--quick", choice, {1, 2, 3});
@@ -75,13 +72,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", "[deprecated]") {
 
     int choice;
     app.add_set("-q,--quick", choice, {1, 2, 3});
@@ -89,28 +86,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", "[deprecated]") {
 
     int choice;
     app.add_set("-q,--quick", choice, {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", "[deprecated]") {
 
     int choice;
     std::set<int> vals{1, 2, 3};
@@ -118,14 +115,14 @@ TEST_F(TApp, FailMutableSet) {
     app.add_mutable_set("-s,--slow", choice, vals, "", true);
 
     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);
 }
 
 // #113
-TEST_F(TApp, AddRemoveSetItems) {
+TEST_CASE_METHOD(TApp, "AddRemoveSetItems", "[deprecated]") {
     std::set<std::string> items{"TYPE1", "TYPE2", "TYPE3", "TYPE4", "TYPE5"};
 
     std::string type1, type2;
@@ -135,8 +132,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");
@@ -146,17 +143,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(THelp, Defaults) {
+TEST_CASE("THelp: Defaults", "[deprecated]") {
     CLI::App app{"My prog"};
 
     int one{1}, two{2};
@@ -165,24 +162,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 +187,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 +203,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 +224,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 +248,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/tests/FormatterTest.cpp b/tests/FormatterTest.cpp
index 513f956a..22da56f0 100644
--- a/tests/FormatterTest.cpp
+++ b/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/tests/HelpTest.cpp b/tests/HelpTest.cpp
index a6169dfe..48089f6f 100644
--- a/tests/HelpTest.cpp
+++ b/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"));
+    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"));
 
-    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");
+    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_F(CapturedHelp, NewFormattedHelp) {
+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")));
+    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_F(CapturedHelp, AllOnlyError) {
+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")));
+    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_F(CapturedHelp, ReplacedError) {
+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/tests/HelpersTest.cpp b/tests/HelpersTest.cpp
index 993b8a9f..ae1d009d 100644
--- a/tests/HelpersTest.cpp
+++ b/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");
+    CHECK("aba" == newString);
 }
 
-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_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(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_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(Trim, Various) {
+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));
+    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));
+    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));
+    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/tests/NewParseTest.cpp b/tests/NewParseTest.cpp
index cf0adc38..d9d9dbf9 100644
--- a/tests/NewParseTest.cpp
+++ b/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/tests/OptionGroupTest.cpp b/tests/OptionGroupTest.cpp
index e510c1a3..175f31dc 100644
--- a/tests/OptionGroupTest.cpp
+++ b/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/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
index bbf71fdf..a2f893be 100644
--- a/tests/OptionTypeTest.cpp
+++ b/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() {}
-};
+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;
 
-using containerTypes_single =
-    ::testing::Types<std::vector<int>, std::deque<int>, std::set<int>, std::list<int>, std::unordered_set<int>>;
+    CLI::Option *opt = tapp.app.add_option("-v", cv);
 
-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());
+    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, );
+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;
 
-TYPED_TEST(TApp_container_tuple, containerTuple) {
+    (tapp.app).add_option("--dict", cv);
 
-    auto &cv = TApp_container_tuple<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 = 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_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;
 
-template <class T> class TApp_container_container : public TApp {
-  public:
-    using container_type = T;
-    container_type cval{};
-    TApp_container_container() : TApp() {}
-};
+    (tapp.app).add_option("--dict", cv);
 
-TYPED_TEST_SUITE(TApp_container_container, containerTypes_container, );
+    tapp.args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
 
-TYPED_TEST(TApp_container_container, containerContainer) {
+    tapp.run();
+    CHECK(2u == cv.size());
 
-    auto &cv = TApp_container_container<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);
+    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/tests/OptionalTest.cpp b/tests/OptionalTest.cpp
index 51f159aa..4d8da020 100644
--- a/tests/OptionalTest.cpp
+++ b/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/tests/SetTest.cpp b/tests/SetTest.cpp
index 7b6236ed..d34a67a6 100644
--- a/tests/SetTest.cpp
+++ b/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/tests/SimpleTest.cpp b/tests/SimpleTest.cpp
index dfcd5579..92262b5e 100644
--- a/tests/SimpleTest.cpp
+++ b/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/tests/StringParseTest.cpp b/tests/StringParseTest.cpp
index 568bb4ec..3a9f7371 100644
--- a/tests/StringParseTest.cpp
+++ b/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/tests/SubcommandTest.cpp b/tests/SubcommandTest.cpp
index e6f96134..eef67bca 100644
--- a/tests/SubcommandTest.cpp
+++ b/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/tests/TimerTest.cpp b/tests/TimerTest.cpp
index 51d8bb09..8c88f478 100644
--- a/tests/TimerTest.cpp
+++ b/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/tests/TransformTest.cpp b/tests/TransformTest.cpp
index 53df504a..84ac544a 100644
--- a/tests/TransformTest.cpp
+++ b/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/tests/TrueFalseTest.cpp b/tests/TrueFalseTest.cpp
index 7c37d456..aa8886c0 100644
--- a/tests/TrueFalseTest.cpp
+++ b/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"));
+TEST_CASE_METHOD(TApp, "False Bool Option", "[bool][flag]") {
+    auto param = GENERATE(as<std::string>{}, "false", "off", "False", "OFF");
 
-/// 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_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/tests/WindowsTest.cpp b/tests/WindowsTest.cpp
index 41053bbe..84726664 100644
--- a/tests/WindowsTest.cpp
+++ b/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/tests/link_test_2.cpp b/tests/link_test_2.cpp
index ba4cc8fe..b8544ab4 100644
--- a/tests/link_test_2.cpp
+++ b/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/tests/main.cpp b/tests/main.cpp
new file mode 100644
index 00000000..0c7c351f
--- /dev/null
+++ b/tests/main.cpp
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"