Replace UnitTest-cpp with Catch

This PR replaces UnitTest-cpp with Catch. Catch is downloaded
using cmake's ExternalProject_Add and installed into the
include directory as it's a header only library.

Signed-off-by: Rian Quinn <“rianquinn@gmail.com”>

.gitignore

@@ -1,4 +1,6 @@
 CMakeFiles
+build
+include/catch
 tests/CMakeFiles
 tests/Debug
 *.opensdf

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "tests/unittest-cpp"]
-	path = tests/unittest-cpp
-	url = https://github.com/unittest-cpp/unittest-cpp.git

.travis.yml

@@ -10,7 +10,7 @@ cache:
     - ${TRAVIS_BUILD_DIR}/deps/llvm-3.6.2/install
     - ${TRAVIS_BUILD_DIR}/deps/llvm-3.7.1/install
     - ${TRAVIS_BUILD_DIR}/deps/llvm-3.8.1/install
-    - ${TRAVIS_BUILD_DIR}/deps/llvm-3.9.0/install
+    - ${TRAVIS_BUILD_DIR}/deps/llvm-3.9.1/install
 
 matrix:
   include:
@@ -61,6 +61,19 @@ matrix:
     - env: CLANG_VERSION=3.8 BUILD_TYPE=Release
       os: linux
       addons: *clang38
+    - env: CLANG_VERSION=3.9 BUILD_TYPE=Debug
+      os: linux
+      addons: &clang39
+        apt:
+          packages:
+            - clang-3.9
+            - g++-5
+          sources: &sources
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+    - env: CLANG_VERSION=3.9 BUILD_TYPE=Release
+      os: linux
+      addons: *clang39
     - env: GCC_VERSION=5 BUILD_TYPE=Debug
       os: linux
       addons: &gcc5
@@ -110,7 +123,7 @@ install:
       if [[ "$CLANG_VERSION" == "3.6" ]]; then LLVM_VERSION="3.6.2"; fi
       if [[ "$CLANG_VERSION" == "3.7" ]]; then LLVM_VERSION="3.7.1"; fi
       if [[ "$CLANG_VERSION" == "3.8" ]]; then LLVM_VERSION="3.8.1"; fi
-      if [[ "$CLANG_VERSION" == "3.9" ]]; then LLVM_VERSION="3.9.0"; fi
+      if [[ "$CLANG_VERSION" == "3.9" ]]; then LLVM_VERSION="3.9.1"; fi
       LLVM_ROOT="${DEPS_DIR}/llvm-${LLVM_VERSION}"
       LLVM_URL="http://llvm.org/releases/${LLVM_VERSION}/llvm-${LLVM_VERSION}.src.tar.xz"
       LIBCXX_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxx-${LLVM_VERSION}.src.tar.xz"

CMakeLists.txt

@@ -2,12 +2,15 @@ cmake_minimum_required(VERSION 2.8.7)
 
 project(GSL CXX)
 
+include(ExternalProject)
+find_package(Git REQUIRED)
+
 # creates a library GSL which is an interface (header files only)
 add_library(GSL INTERFACE)
 
 # when minimum version required is 3.8.0 remove if below
 # both branches do exactly the same thing
-if ( CMAKE_MAJOR_VERSION VERSION_LESS 3.7.9)
+if (CMAKE_MAJOR_VERSION VERSION_LESS 3.7.9)
     if (NOT MSVC)
         include(CheckCXXCompilerFlag)
         CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)

README.md

@@ -40,8 +40,6 @@ contributing any changes that were necessary back to this project to benefit the
 To build the tests, you will require the following:
 
 * [CMake](http://cmake.org), version 2.8.7 or later to be installed and in your PATH.
-* [UnitTest-cpp](https://github.com/Microsoft/unittest-cpp), to be cloned under the [tests/unittest-cpp](./tests/unittest-cpp) directory
-of your GSL source.
 
 These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.
 

appveyor.yml

@@ -13,16 +13,15 @@ image:
   - Visual Studio 2017
 
 cache:
-  - C:\cmake-3.7.2-win32-x86
+  - C:\cmake-3.8.0-win32-x86
 
 install:
-  - git clone --quiet --depth=1 https://github.com/Microsoft/unittest-cpp.git tests/unittest-cpp
   - ps: |
-      if (![IO.File]::Exists("C:\cmake-3.7.2-win32-x86\bin\cmake.exe")) {
+      if (![IO.File]::Exists("C:\cmake-3.8.0-win32-x86\bin\cmake.exe")) {
-        Start-FileDownload 'https://cmake.org/files/v3.7/cmake-3.7.2-win32-x86.zip'
+        Start-FileDownload 'https://cmake.org/files/v3.8/cmake-3.8.0-win32-x86.zip'
-        7z x -y cmake-3.7.2-win32-x86.zip -oC:\
+        7z x -y cmake-3.8.0-win32-x86.zip -oC:\
       }
-      $env:PATH="C:\cmake-3.7.2-win32-x86\bin;$env:PATH"
+      $env:PATH="C:\cmake-3.8.0-win32-x86\bin;$env:PATH"
 
 before_build:
   - ps: |

include/gsl/multi_span

@@ -41,6 +41,7 @@
 // turn off some warnings that are noisy about our Expects statements
 #pragma warning(push)
 #pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4702) // unreachable code
 
 #if _MSC_VER < 1910
 #pragma push_macro("constexpr")

include/gsl/span

@@ -37,6 +37,7 @@
 
 // turn off some warnings that are noisy about our Expects statements
 #pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4702) // unreachable code
 
 // blanket turn off warnings from CppCoreCheck for now
 // so people aren't annoyed by them when running the tool.

tests/CMakeLists.txt

@@ -5,15 +5,21 @@ project(GSLTests CXX)
 # will make visual studio generated project group files
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/unittest-cpp/CMakeLists.txt)
+list(APPEND CATCH_CMAKE_ARGS
-    find_package(Git)
+    "-DCMAKE_INSTALL_PREFIX=${CMAKE_SOURCE_DIR}"
-    execute_process(
+    "-DNO_SELFTEST=true"
-        COMMAND ${GIT_EXECUTABLE} submodule update --init
+)
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    )
-endif()
 
-add_subdirectory(unittest-cpp)
+# add catch
+ExternalProject_Add(
+    catch
+    PREFIX ${CMAKE_BINARY_DIR}/catch
+    GIT_REPOSITORY https://github.com/philsquared/Catch.git
+#    GIT_TAG v1.9.4    uncomment once v1.9.4 is available
+    CMAKE_ARGS ${CATCH_CMAKE_ARGS}
+    LOG_DOWNLOAD 1
+    UPDATE_DISCONNECTED 1
+)
 
 # this interface adds compile options to how the tests are run
 # please try to keep entries ordered =)
@@ -42,24 +48,29 @@ target_compile_options(gsl_tests_config INTERFACE
     >
 )
 
-# set test to include the unittest-cpp headers
-# this shiuld be removed when UnitTest++ has the proper headers
-target_include_directories(gsl_tests_config INTERFACE
-    ./unittest-cpp
-)
-
 # set definitions for tests
 target_compile_definitions(gsl_tests_config INTERFACE
     GSL_THROW_ON_CONTRACT_VIOLATION
 )
 
+# create the main executable for each test. this reduces the compile time
+# of each test by pre-compiling catch.
+add_library(test_catch STATIC test.cpp)
+target_link_libraries(test_catch
+    GSL
+    gsl_tests_config
+)
+add_dependencies(test_catch catch)
+set_property(TARGET test_catch PROPERTY FOLDER "GSL_tests")
+
 function(add_gsl_test name)
     add_executable(${name} ${name}.cpp)
     target_link_libraries(${name}
-        UnitTest++
         GSL
+        test_catch
         gsl_tests_config
     )
+    add_dependencies(${name} catch)
     add_test(
       ${name}
       ${name}

tests/algorithm_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl_algorithm>
 
@@ -23,11 +23,8 @@
 using namespace std;
 using namespace gsl;
 
-SUITE(copy_tests)
+TEST_CASE("same_type")
 {
-
-    TEST(same_type)
-    {
     // dynamic source and destination span
     {
         std::array<int, 5> src{1, 2, 3, 4, 5};
@@ -95,10 +92,10 @@ SUITE(copy_tests)
             CHECK(dst[i + src.size()] == src[i]);
         }
     }
-    }
+}
 
-    TEST(compatible_type)
+TEST_CASE("compatible_type")
-    {
+{
     // dynamic source and destination span
     {
         std::array<short, 5> src{1, 2, 3, 4, 5};
@@ -166,11 +163,11 @@ SUITE(copy_tests)
             CHECK(dst[i + src.size()] == src[i]);
         }
     }
-    }
+}
 
 #ifdef CONFIRM_COMPILATION_ERRORS
-    TEST(incompatible_type)
+TEST_CASE("incompatible_type")
-    {
+{
     std::array<int, 4> src{1, 2, 3, 4};
     std::array<int*, 12> dst{};
 
@@ -184,11 +181,11 @@ SUITE(copy_tests)
     copy(src_span_dyn, dst_span_static);
     copy(src_span_static, dst_span_dyn);
     copy(src_span_static, dst_span_static);
-    }
+}
 #endif
 
-    TEST(small_destination_span)
+TEST_CASE("small_destination_span")
-    {
+{
     std::array<int, 12> src{1, 2, 3, 4};
     std::array<int, 4> dst{};
 
@@ -197,14 +194,11 @@ SUITE(copy_tests)
     span<int> dst_span_dyn(dst);
     span<int, 4> dst_span_static(dst);
 
-        CHECK_THROW(copy(src_span_dyn, dst_span_dyn), fail_fast);
+    CHECK_THROWS_AS(copy(src_span_dyn, dst_span_dyn), fail_fast);
-        CHECK_THROW(copy(src_span_dyn, dst_span_static), fail_fast);
+    CHECK_THROWS_AS(copy(src_span_dyn, dst_span_static), fail_fast);
-        CHECK_THROW(copy(src_span_static, dst_span_dyn), fail_fast);
+    CHECK_THROWS_AS(copy(src_span_static, dst_span_dyn), fail_fast);
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     copy(src_span_static, dst_span_static);
 #endif
-    }
 }
-
-int main() { return UnitTest::RunAllTests(); }

tests/assertion_tests.cpp

@@ -14,38 +14,33 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl>
 
 using namespace gsl;
 
-SUITE(assertion_tests)
+int f(int i)
 {
-    int f(int i)
-    {
     Expects(i > 0 && i < 10);
     return i;
-    }
+}
 
-    TEST(expects)
+TEST_CASE("expects")
-    {
+{
     CHECK(f(2) == 2);
-        CHECK_THROW(f(10), fail_fast);
+    CHECK_THROWS_AS(f(10), fail_fast);
-    }
+}
 
-    int g(int i)
+int g(int i)
-    {
+{
     i++;
     Ensures(i > 0 && i < 10);
     return i;
-    }
-
-    TEST(ensures)
-    {
-        CHECK(g(2) == 3);
-        CHECK_THROW(g(9), fail_fast);
-    }
 }
 
-int main(int, const char* []) { return UnitTest::RunAllTests(); }
+TEST_CASE("ensures")
+{
+    CHECK(g(2) == 3);
+    CHECK_THROWS_AS(g(9), fail_fast);
+}

tests/at_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl>
 
@@ -23,10 +23,8 @@
 
 using gsl::fail_fast;
 
-SUITE(at_tests)
+TEST_CASE("static_array")
 {
-    TEST(static_array)
-    {
     int a[4] = {1, 2, 3, 4};
     const int(&c_a)[4] = a;
 
@@ -35,14 +33,14 @@ SUITE(at_tests)
         CHECK(&gsl::at(c_a, i) == &a[i]);
     }
 
-        CHECK_THROW(gsl::at(a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
-        CHECK_THROW(gsl::at(a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
-        CHECK_THROW(gsl::at(c_a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(c_a, -1), fail_fast);
-        CHECK_THROW(gsl::at(c_a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(c_a, 4), fail_fast);
-    }
+}
 
-    TEST(std_array)
+TEST_CASE("std_array")
-    {
+{
     std::array<int, 4> a = {1, 2, 3, 4};
     const std::array<int, 4>& c_a = a;
 
@@ -51,14 +49,14 @@ SUITE(at_tests)
         CHECK(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
     }
 
-        CHECK_THROW(gsl::at(a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
-        CHECK_THROW(gsl::at(a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
-        CHECK_THROW(gsl::at(c_a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(c_a, -1), fail_fast);
-        CHECK_THROW(gsl::at(c_a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(c_a, 4), fail_fast);
-    }
+}
 
-    TEST(StdVector)
+TEST_CASE("StdVector")
-    {
+{
     std::vector<int> a = {1, 2, 3, 4};
     const std::vector<int>& c_a = a;
 
@@ -67,14 +65,14 @@ SUITE(at_tests)
         CHECK(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
     }
 
-        CHECK_THROW(gsl::at(a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
-        CHECK_THROW(gsl::at(a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
-        CHECK_THROW(gsl::at(c_a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(c_a, -1), fail_fast);
-        CHECK_THROW(gsl::at(c_a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(c_a, 4), fail_fast);
-    }
+}
 
-    TEST(InitializerList)
+TEST_CASE("InitializerList")
-    {
+{
     std::initializer_list<int> a = {1, 2, 3, 4};
 
     for (int i = 0; i < 4; ++i) {
@@ -82,11 +80,10 @@ SUITE(at_tests)
         CHECK(gsl::at({1, 2, 3, 4}, i) == i + 1);
     }
 
-        CHECK_THROW(gsl::at(a, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
-        CHECK_THROW(gsl::at(a, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
-        CHECK_THROW(gsl::at({1, 2, 3, 4}, -1), fail_fast);
+    CHECK_THROWS_AS(gsl::at({1, 2, 3, 4}, -1), fail_fast);
-        CHECK_THROW(gsl::at({1, 2, 3, 4}, 4), fail_fast);
+    CHECK_THROWS_AS(gsl::at({1, 2, 3, 4}, 4), fail_fast);
-    }
 }
 
 #if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1910
@@ -111,5 +108,3 @@ static constexpr bool test_constexpr()
 
 static_assert(test_constexpr(), "FAIL");
 #endif
-
-int main() { return UnitTest::RunAllTests(); }

tests/bounds_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/multi_span>
 
@@ -28,10 +28,8 @@ namespace
 void use(std::ptrdiff_t&) {}
 }
 
-SUITE(bounds_test)
+TEST_CASE("basic_bounds")
 {
-    TEST(basic_bounds)
-    {
     for (auto point : static_bounds<dynamic_range, 3, 4>{2}) {
         for (decltype(point)::size_type j = 0;
              j < static_cast<decltype(point)::size_type>(decltype(point)::rank); j++)
@@ -40,19 +38,19 @@ SUITE(bounds_test)
             use(point[static_cast<std::size_t>(j)]);
         }
     }
-    }
+}
 
-    TEST(bounds_basic)
+TEST_CASE("bounds_basic")
-    {
+{
     static_bounds<3, 4, 5> b;
     const auto a = b.slice();
     (void) a;
     static_bounds<4, dynamic_range, 2> x{4};
     x.slice().slice();
-    }
+}
 
-    TEST(arrayview_iterator)
+TEST_CASE("arrayview_iterator")
-    {
+{
     static_bounds<4, dynamic_range, 2> bounds{3};
 
     const auto itr = bounds.begin();
@@ -67,10 +65,10 @@ SUITE(bounds_test)
     }
     fill(av.begin(), av.end(), 0);
 #endif
-    }
+}
 
-    TEST(bounds_convertible)
+TEST_CASE("bounds_convertible")
-    {
+{
     static_bounds<7, 4, 2> b1;
     static_bounds<7, dynamic_range, 2> b2 = b1;
     (void) b2;
@@ -88,13 +86,10 @@ SUITE(bounds_test)
     static_bounds<34> b6;
 
     b5 = static_bounds<20>();
-        CHECK_THROW(b6 = b5, fail_fast);
+    CHECK_THROWS_AS(b6 = b5, fail_fast);
     b5 = static_bounds<34>();
     b6 = b5;
 
     CHECK(b5 == b6);
     CHECK(b5.size() == b6.size());
-    }
 }
-
-int main(int, const char* []) { return UnitTest::RunAllTests(); }

tests/byte_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl_byte>
 
@@ -31,10 +31,8 @@ using namespace gsl;
 namespace
 {
 
-SUITE(byte_tests)
+TEST_CASE("construction")
 {
-    TEST(construction)
-    {
     {
         const byte b = static_cast<byte>(4);
         CHECK(static_cast<unsigned char>(b) == 4);
@@ -60,10 +58,10 @@ SUITE(byte_tests)
     //    byte b { 14 };
     //    CHECK(static_cast<unsigned char>(b) == 14);
     //}
-    }
+}
 
-    TEST(bitwise_operations)
+TEST_CASE("bitwise_operations")
-    {
+{
     const byte b = to_byte<0xFF>();
 
     byte a = to_byte<0x00>();
@@ -96,10 +94,10 @@ SUITE(byte_tests)
     CHECK(a == to_byte<0xF0>());
     a >>= 4;
     CHECK(a == to_byte<0x0F>());
-    }
+}
 
-    TEST(to_integer)
+TEST_CASE("to_integer")
-    {
+{
     const byte b = to_byte<0x12>();
 
     CHECK(0x12 == gsl::to_integer<char>(b));
@@ -114,22 +112,20 @@ SUITE(byte_tests)
 
     //      CHECK(0x12 == gsl::to_integer<float>(b));   // expect compile-time error
     //      CHECK(0x12 == gsl::to_integer<double>(b));  // expect compile-time error
-    }
+}
 
-    int modify_both(gsl::byte & b, int& i)
+int modify_both(gsl::byte & b, int& i)
-    {
+{
     i = 10;
     b = to_byte<5>();
     return i;
-    }
+}
 
-    TEST(aliasing)
+TEST_CASE("aliasing")
-    {
+{
     int i{0};
     const int res = modify_both(reinterpret_cast<byte&>(i), i);
     CHECK(res == i);
-    }
-}
 }
 
-int main(int, const char* []) { return UnitTest::RunAllTests(); }
+}

tests/notnull_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl>
 
@@ -95,13 +95,10 @@ std::string operator>=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
                                                                                           : "false";
 }
 
-SUITE(NotNullTests)
+bool helper(not_null<int*> p) { return *p == 12; }
+
+TEST_CASE("TestNotNullConstructors")
 {
-
-    bool helper(not_null<int*> p) { return *p == 12; }
-
-    TEST(TestNotNullConstructors)
-    {
 #ifdef CONFIRM_COMPILATION_ERRORS
     not_null<int*> p = nullptr;         // yay...does not compile!
     not_null<std::vector<char>*> p = 0; // yay...does not compile!
@@ -121,10 +118,10 @@ SUITE(NotNullTests)
 
     not_null<std::shared_ptr<int>> x(
         std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
-    }
+}
 
-    TEST(TestNotNullCasting)
+TEST_CASE("TestNotNullCasting")
-    {
+{
     MyBase base;
     MyDerived derived;
     Unrelated unrelated;
@@ -144,20 +141,20 @@ SUITE(NotNullTests)
 #endif
     not_null<Unrelated*> t = reinterpret_cast<Unrelated*>(p.get());
     CHECK(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
-    }
+}
 
-    TEST(TestNotNullAssignment)
+TEST_CASE("TestNotNullAssignment")
-    {
+{
     int i = 12;
     not_null<int*> p = &i;
     CHECK(helper(p));
 
     int* q = nullptr;
-        CHECK_THROW(p = q, fail_fast);
+    CHECK_THROWS_AS(p = q, fail_fast);
-    }
+}
 
-    TEST(TestNotNullRawPointerComparison)
+TEST_CASE("TestNotNullRawPointerComparison")
-    {
+{
     int ints[2] = {42, 43};
     int* p1 = &ints[0];
     const int* p2 = &ints[1];
@@ -186,10 +183,10 @@ SUITE(NotNullTests)
     CHECK((NotNull1(p1) >= NotNull1(p1)) == true);
     CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
     CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
-    }
+}
 
-    TEST(TestNotNullSharedPtrComparison)
+TEST_CASE("TestNotNullSharedPtrComparison")
-    {
+{
     auto sp1 = std::make_shared<int>(42);
     auto sp2 = std::make_shared<const int>(43);
 
@@ -217,10 +214,10 @@ SUITE(NotNullTests)
     CHECK((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
     CHECK((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
     CHECK((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
-    }
+}
 
-    TEST(TestNotNullCustomPtrComparison)
+TEST_CASE("TestNotNullCustomPtrComparison")
-    {
+{
     int ints[2] = {42, 43};
     CustomPtr<int> p1(&ints[0]);
     CustomPtr<const int> p2(&ints[1]);
@@ -249,7 +246,4 @@ SUITE(NotNullTests)
     CHECK((NotNull1(p1) >= NotNull1(p1)) == "true");
     CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
     CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
-    }
 }
-
-int main(int, const char* []) { return UnitTest::RunAllTests(); }

tests/owner_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl>
 
@@ -22,18 +22,13 @@
 
 using namespace gsl;
 
-SUITE(owner_tests)
+void f(int* i) { *i += 1; }
-{
-    void f(int* i) { *i += 1; }
 
-    TEST(basic_test)
+TEST_CASE("basic_test")
-    {
+{
     owner<int*> p = new int(120);
     CHECK(*p == 120);
     f(p);
     CHECK(*p == 121);
     delete p;
-    }
 }
-
-int main(int, const char* []) { return UnitTest::RunAllTests(); }

tests/strided_span_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/multi_span>
 
@@ -38,20 +38,18 @@ struct DerivedClass : BaseClass
 };
 }
 
-SUITE(strided_span_tests)
+TEST_CASE("span_section_test")
 {
-    TEST(span_section_test)
-    {
     int a[30][4][5];
 
     const auto av = as_multi_span(a);
     const auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2});
     const auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1});
     (void) subsub;
-    }
+}
 
-    TEST(span_section)
+TEST_CASE("span_section")
-    {
+{
     std::vector<int> data(5 * 10);
     std::iota(begin(data), end(data), 0);
     const multi_span<int, 5, 10> av = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>());
@@ -66,10 +64,10 @@ SUITE(strided_span_tests)
     CHECK((av_section_2[{0, 0}] == 24));
     CHECK((av_section_2[{0, 1}] == 25));
     CHECK((av_section_2[{1, 0}] == 34));
-    }
+}
 
-    TEST(strided_span_constructors)
+TEST_CASE("strided_span_constructors")
-    {
+{
     // Check stride constructor
     {
         int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -78,12 +76,12 @@ SUITE(strided_span_tests)
         strided_span<int, 1> sav1{arr, {{9}, {1}}}; // T -> T
         CHECK(sav1.bounds().index_bounds() == index<1>{9});
         CHECK(sav1.bounds().stride() == 1);
-            CHECK(sav1[0] == 1 && sav1[8] == 9);
+        CHECK((sav1[0] == 1 && sav1[8] == 9));
 
         strided_span<const int, 1> sav2{carr, {{4}, {2}}}; // const T -> const T
         CHECK(sav2.bounds().index_bounds() == index<1>{4});
         CHECK(sav2.bounds().strides() == index<1>{2});
-            CHECK(sav2[0] == 1 && sav2[3] == 7);
+        CHECK((sav2[0] == 1 && sav2[3] == 7));
 
         strided_span<int, 2> sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T
         CHECK((sav3.bounds().index_bounds() == index<2>{2, 2}));
@@ -266,10 +264,10 @@ SUITE(strided_span_tests)
         CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
         CHECK(&sav2_ref == &sav2);
     }
-    }
+}
 
-    TEST(strided_span_slice)
+TEST_CASE("strided_span_slice")
-    {
+{
     std::vector<int> data(5 * 10);
     std::iota(begin(data), end(data), 0);
     const multi_span<int, 5, 10> src =
@@ -292,10 +290,10 @@ SUITE(strided_span_tests)
 
     CHECK(sav[4][0] == 40);
     CHECK(sav[4][9] == 49);
-    }
+}
 
-    TEST(strided_span_column_major)
+TEST_CASE("strided_span_column_major")
-    {
+{
     // strided_span may be used to accomodate more peculiar
     // use cases, such as column-major multidimensional array
     // (aka. "FORTRAN" layout).
@@ -324,25 +322,25 @@ SUITE(strided_span_tests)
     CHECK((cm_sec[{0, 1}] == 9));
     CHECK((cm_sec[{1, 0}] == 11));
     CHECK((cm_sec[{2, 1}] == 15));
-    }
+}
 
-    TEST(strided_span_bounds)
+TEST_CASE("strided_span_bounds")
-    {
+{
     int arr[] = {0, 1, 2, 3};
     multi_span<int> av(arr);
 
     {
         // incorrect sections
 
-            CHECK_THROW(av.section(0, 0)[0], fail_fast);
+        CHECK_THROWS_AS(av.section(0, 0)[0], fail_fast);
-            CHECK_THROW(av.section(1, 0)[0], fail_fast);
+        CHECK_THROWS_AS(av.section(1, 0)[0], fail_fast);
-            CHECK_THROW(av.section(1, 1)[1], fail_fast);
+        CHECK_THROWS_AS(av.section(1, 1)[1], fail_fast);
 
-            CHECK_THROW(av.section(2, 5), fail_fast);
+        CHECK_THROWS_AS(av.section(2, 5), fail_fast);
-            CHECK_THROW(av.section(5, 2), fail_fast);
+        CHECK_THROWS_AS(av.section(5, 2), fail_fast);
-            CHECK_THROW(av.section(5, 0), fail_fast);
+        CHECK_THROWS_AS(av.section(5, 0), fail_fast);
-            CHECK_THROW(av.section(0, 5), fail_fast);
+        CHECK_THROWS_AS(av.section(0, 5), fail_fast);
-            CHECK_THROW(av.section(5, 5), fail_fast);
+        CHECK_THROWS_AS(av.section(5, 5), fail_fast);
     }
 
     {
@@ -350,19 +348,19 @@ SUITE(strided_span_tests)
         strided_span<int, 1> sav{av, {{4}, {}}};
         CHECK(sav[0] == 0);
         CHECK(sav[3] == 0);
-            CHECK_THROW(sav[4], fail_fast);
+        CHECK_THROWS_AS(sav[4], fail_fast);
     }
 
     {
         // zero extent
         strided_span<int, 1> sav{av, {{}, {1}}};
-            CHECK_THROW(sav[0], fail_fast);
+        CHECK_THROWS_AS(sav[0], fail_fast);
     }
 
     {
         // zero extent and stride
         strided_span<int, 1> sav{av, {{}, {}}};
-            CHECK_THROW(sav[0], fail_fast);
+        CHECK_THROWS_AS(sav[0], fail_fast);
     }
 
     {
@@ -370,7 +368,7 @@ SUITE(strided_span_tests)
         strided_span<int, 1> sav{arr, {4, 1}};
         CHECK(sav.bounds().index_bounds() == index<1>{4});
         CHECK(sav[3] == 3);
-            CHECK_THROW(sav[4], fail_fast);
+        CHECK_THROWS_AS(sav[4], fail_fast);
     }
 
     {
@@ -378,7 +376,7 @@ SUITE(strided_span_tests)
         strided_span<int, 1> sav{arr, {2, 1}};
         CHECK(sav.bounds().index_bounds() == index<1>{2});
         CHECK(sav[1] == 1);
-            CHECK_THROW(sav[2], fail_fast);
+        CHECK_THROWS_AS(sav[2], fail_fast);
     }
 
     {
@@ -387,35 +385,35 @@ SUITE(strided_span_tests)
         CHECK(sav.bounds().index_bounds() == index<1>{2});
         CHECK(sav[0] == 0);
         CHECK(sav[1] == 3);
-            CHECK_THROW(sav[2], fail_fast);
+        CHECK_THROWS_AS(sav[2], fail_fast);
     }
 
     {
         // bounds cross data boundaries - from static arrays
-            CHECK_THROW((strided_span<int, 1>{arr, {3, 2}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{arr, {3, 2}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{arr, {3, 3}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{arr, {3, 3}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{arr, {4, 5}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{arr, {4, 5}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{arr, {5, 1}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{arr, {5, 1}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{arr, {5, 5}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{arr, {5, 5}}), fail_fast);
     }
 
     {
         // bounds cross data boundaries - from array view
-            CHECK_THROW((strided_span<int, 1>{av, {3, 2}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av, {3, 2}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av, {3, 3}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av, {3, 3}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av, {4, 5}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av, {4, 5}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av, {5, 1}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av, {5, 1}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av, {5, 5}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av, {5, 5}}), fail_fast);
     }
 
     {
         // bounds cross data boundaries - from dynamic arrays
-            CHECK_THROW((strided_span<int, 1>{av.data(), 4, {3, 2}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {3, 2}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av.data(), 4, {3, 3}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {3, 3}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av.data(), 4, {4, 5}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {4, 5}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av.data(), 4, {5, 1}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {5, 1}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av.data(), 4, {5, 5}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {5, 5}}), fail_fast);
-            CHECK_THROW((strided_span<int, 1>{av.data(), 2, {2, 2}}), fail_fast);
+        CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 2, {2, 2}}), fail_fast);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
@@ -440,10 +438,10 @@ SUITE(strided_span_tests)
         strided_span<int, 2> sav14{av.as_multi_span(dim<2>(), dim<2>()), {{1, 1, 1}, {1}}};
     }
 #endif
-    }
+}
 
-    TEST(strided_span_type_conversion)
+TEST_CASE("strided_span_type_conversion")
-    {
+{
     int arr[] = {0, 1, 2, 3};
     multi_span<int> av(arr);
 
@@ -469,8 +467,8 @@ SUITE(strided_span_tests)
         strided_span<const int, 2> sav3 = sav2.as_strided_span<const int>();
         CHECK(sav3[0][0] == 0);
         CHECK(sav3[1][0] == 2);
-            CHECK_THROW(sav3[1][1], fail_fast);
+        CHECK_THROWS_AS(sav3[1][1], fail_fast);
-            CHECK_THROW(sav3[0][1], fail_fast);
+        CHECK_THROWS_AS(sav3[0][1], fail_fast);
     }
 
     // retype strided array with regular strides - from multi_span
@@ -482,8 +480,8 @@ SUITE(strided_span_tests)
         strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
         CHECK(sav3[0][0] == 0);
         CHECK(sav3[1][0] == 2);
-            CHECK_THROW(sav3[1][1], fail_fast);
+        CHECK_THROWS_AS(sav3[1][1], fail_fast);
-            CHECK_THROW(sav3[0][1], fail_fast);
+        CHECK_THROWS_AS(sav3[0][1], fail_fast);
     }
 
     // retype strided array with not enough elements - last dimension of the array is too small
@@ -492,7 +490,7 @@ SUITE(strided_span_tests)
         multi_span<const byte, 2, dynamic_range> bytes2 =
             as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
         strided_span<const byte, 2> sav2{bytes2, bounds};
-            CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
+        CHECK_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
     }
 
     // retype strided array with not enough elements - strides are too small
@@ -501,7 +499,7 @@ SUITE(strided_span_tests)
         multi_span<const byte, 2, dynamic_range> bytes2 =
             as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
         strided_span<const byte, 2> sav2{bytes2, bounds};
-            CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
+        CHECK_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
     }
 
     // retype strided array with not enough elements - last dimension does not divide by the new
@@ -511,7 +509,7 @@ SUITE(strided_span_tests)
         multi_span<const byte, 2, dynamic_range> bytes2 =
             as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
         strided_span<const byte, 2> sav2{bytes2, bounds};
-            CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
+        CHECK_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
     }
 
     // retype strided array with not enough elements - strides does not divide by the new
@@ -521,34 +519,34 @@ SUITE(strided_span_tests)
         multi_span<const byte, 2, dynamic_range> bytes2 =
             as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
         strided_span<const byte, 2> sav2{bytes2, bounds};
-            CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
+        CHECK_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
     }
 
     // retype strided array with irregular strides - from raw data
     {
         strided_bounds<1> bounds{bytes.size() / 2, 2};
         strided_span<const byte, 1> sav2{bytes.data(), bytes.size(), bounds};
-            CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
+        CHECK_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
     }
 
     // retype strided array with irregular strides - from multi_span
     {
         strided_bounds<1> bounds{bytes.size() / 2, 2};
         strided_span<const byte, 1> sav2{bytes, bounds};
-            CHECK_THROW(sav2.as_strided_span<int>(), fail_fast);
+        CHECK_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
-        }
     }
+}
 
-    TEST(empty_strided_spans)
+TEST_CASE("empty_strided_spans")
-    {
+{
     {
         multi_span<int, 0> empty_av(nullptr);
         strided_span<int, 1> empty_sav{empty_av, {0, 1}};
 
         CHECK(empty_sav.bounds().index_bounds() == index<1>{0});
-            CHECK_THROW(empty_sav[0], fail_fast);
+        CHECK_THROWS_AS(empty_sav[0], fail_fast);
-            CHECK_THROW(empty_sav.begin()[0], fail_fast);
+        CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast);
-            CHECK_THROW(empty_sav.cbegin()[0], fail_fast);
+        CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast);
 
         for (const auto& v : empty_sav) {
             (void) v;
@@ -560,19 +558,19 @@ SUITE(strided_span_tests)
         strided_span<int, 1> empty_sav{nullptr, 0, {0, 1}};
 
         CHECK(empty_sav.bounds().index_bounds() == index<1>{0});
-            CHECK_THROW(empty_sav[0], fail_fast);
+        CHECK_THROWS_AS(empty_sav[0], fail_fast);
-            CHECK_THROW(empty_sav.begin()[0], fail_fast);
+        CHECK_THROWS_AS(empty_sav.begin()[0], fail_fast);
-            CHECK_THROW(empty_sav.cbegin()[0], fail_fast);
+        CHECK_THROWS_AS(empty_sav.cbegin()[0], fail_fast);
 
         for (const auto& v : empty_sav) {
             (void) v;
             CHECK(false);
         }
     }
-    }
+}
 
-    void iterate_every_other_element(multi_span<int, dynamic_range> av)
+void iterate_every_other_element(multi_span<int, dynamic_range> av)
-    {
+{
     // pick every other element
 
     auto length = av.size() / 2;
@@ -594,10 +592,10 @@ SUITE(strided_span_tests)
         CHECK(num == av[2 * idx + 1]);
         idx++;
     }
-    }
+}
 
-    TEST(strided_span_section_iteration)
+TEST_CASE("strided_span_section_iteration")
-    {
+{
     int arr[8] = {4, 0, 5, 1, 6, 2, 7, 3};
 
     // static bounds
@@ -611,10 +609,10 @@ SUITE(strided_span_tests)
         multi_span<int, dynamic_range> av(arr, 8);
         iterate_every_other_element(av);
     }
-    }
+}
 
-    TEST(dynamic_strided_span_section_iteration)
+TEST_CASE("dynamic_strided_span_section_iteration")
-    {
+{
     auto arr = new int[8];
     for (int i = 0; i < 4; ++i) {
         arr[2 * i] = 4 + i;
@@ -625,10 +623,10 @@ SUITE(strided_span_tests)
     iterate_every_other_element(av);
 
     delete[] arr;
-    }
+}
 
-    void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_range> av)
+void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_range> av)
-    {
+{
     const int expected[6] = {2, 3, 10, 11, 18, 19};
     auto section = av.section({0, 1, 0}, {3, 1, 2});
 
@@ -651,10 +649,10 @@ SUITE(strided_span_tests)
         CHECK(num == expected[i]);
         i++;
     }
-    }
+}
 
-    TEST(strided_span_section_iteration_3d)
+TEST_CASE("strided_span_section_iteration_3d")
-    {
+{
     int arr[3][4][2]{};
     for (auto i = 0; i < 3; ++i) {
         for (auto j = 0; j < 4; ++j)
@@ -665,10 +663,10 @@ SUITE(strided_span_tests)
         multi_span<int, 3, 4, 2> av = arr;
         iterate_second_slice(av);
     }
-    }
+}
 
-    TEST(dynamic_strided_span_section_iteration_3d)
+TEST_CASE("dynamic_strided_span_section_iteration_3d")
-    {
+{
     const auto height = 12, width = 2;
     const auto size = height * width;
 
@@ -697,10 +695,10 @@ SUITE(strided_span_tests)
         iterate_second_slice(av);
     }
     delete[] arr;
-    }
+}
 
-    TEST(strided_span_conversion)
+TEST_CASE("strided_span_conversion")
-    {
+{
     // get an multi_span of 'c' values from the list of X's
 
     struct X
@@ -744,14 +742,11 @@ SUITE(strided_span_tests)
     strided_span<int, 1> result = transposed[0];
 
     CHECK(result.bounds().index_bounds()[0] == 4);
-        CHECK_THROW(result.bounds().index_bounds()[1], fail_fast);
+    CHECK_THROWS_AS(result.bounds().index_bounds()[1], fail_fast);
 
     int i = 0;
     for (auto& num : result) {
         CHECK(num == arr[i].c);
         i++;
     }
-    }
 }
-
-int main(int, const char* []) { return UnitTest::RunAllTests(); }

tests/string_span_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl> //owner
 #include <gsl/string_span>
@@ -26,35 +26,32 @@
 using namespace std;
 using namespace gsl;
 
-SUITE(string_span_tests)
+TEST_CASE("TestLiteralConstruction")
 {
-
-    TEST(TestLiteralConstruction)
-    {
     cwstring_span<> v = ensure_z(L"Hello");
     CHECK(5 == v.length());
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     wstring_span<> v2 = ensure0(L"Hello");
 #endif
-    }
+}
 
-    TEST(TestConstructFromStdString)
+TEST_CASE("TestConstructFromStdString")
-    {
+{
     std::string s = "Hello there world";
     cstring_span<> v = s;
     CHECK(v.length() == static_cast<cstring_span<>::index_type>(s.length()));
-    }
+}
 
-    TEST(TestConstructFromStdVector)
+TEST_CASE("TestConstructFromStdVector")
-    {
+{
     std::vector<char> vec(5, 'h');
     string_span<> v{vec};
     CHECK(v.length() == static_cast<string_span<>::index_type>(vec.size()));
-    }
+}
 
-    TEST(TestStackArrayConstruction)
+TEST_CASE("TestStackArrayConstruction")
-    {
+{
     wchar_t stack_string[] = L"Hello";
 
     {
@@ -76,25 +73,25 @@ SUITE(string_span_tests)
         wstring_span<> v = stack_string;
         CHECK(v.length() == 5);
     }
-    }
+}
 
-    TEST(TestConstructFromConstCharPointer)
+TEST_CASE("TestConstructFromConstCharPointer")
-    {
+{
     const char* s = "Hello";
     cstring_span<> v = ensure_z(s);
     CHECK(v.length() == 5);
-    }
+}
 
-    TEST(TestConversionToConst)
+TEST_CASE("TestConversionToConst")
-    {
+{
     char stack_string[] = "Hello";
     string_span<> v = ensure_z(stack_string);
     cstring_span<> v2 = v;
     CHECK(v.length() == v2.length());
-    }
+}
 
-    TEST(TestConversionFromConst)
+TEST_CASE("TestConversionFromConst")
-    {
+{
     char stack_string[] = "Hello";
     cstring_span<> v = ensure_z(stack_string);
     (void) v;
@@ -102,10 +99,10 @@ SUITE(string_span_tests)
     string_span<> v2 = v;
     string_span<> v3 = "Hello";
 #endif
-    }
+}
 
-    TEST(TestToString)
+TEST_CASE("TestToString")
-    {
+{
     auto s = gsl::to_string(cstring_span<>{});
     CHECK(s.length() == 0);
 
@@ -114,10 +111,10 @@ SUITE(string_span_tests)
     auto s2 = gsl::to_string(v);
     CHECK(static_cast<cstring_span<>::index_type>(s2.length()) == v.length());
     CHECK(s2.length() == 5);
-    }
+}
 
-    TEST(TestToBasicString)
+TEST_CASE("TestToBasicString")
-    {
+{
     auto s = gsl::to_basic_string<char, std::char_traits<char>, ::std::allocator<char>>(
         cstring_span<>{});
     CHECK(s.length() == 0);
@@ -127,10 +124,10 @@ SUITE(string_span_tests)
     auto s2 = gsl::to_basic_string<char, std::char_traits<char>, ::std::allocator<char>>(v);
     CHECK(static_cast<cstring_span<>::index_type>(s2.length()) == v.length());
     CHECK(s2.length() == 5);
-    }
+}
 
-    TEST(EqualityAndImplicitConstructors)
+TEST_CASE("EqualityAndImplicitConstructors")
-    {
+{
     {
         cstring_span<> span = "Hello";
         cstring_span<> span1;
@@ -353,10 +350,10 @@ SUITE(string_span_tests)
         // comparison of spans from the same vector before and after move (ok)
         CHECK(span1 == span2);
     }
-    }
+}
 
-    TEST(ComparisonAndImplicitConstructors)
+TEST_CASE("ComparisonAndImplicitConstructors")
-    {
+{
     {
         cstring_span<> span = "Hello";
 
@@ -424,9 +421,9 @@ SUITE(string_span_tests)
         // comparison to vector of charaters with no null termination
         CHECK(span >= string_span<>(vec));
     }
-    }
+}
-    TEST(ConstrutorsEnsureZ)
+TEST_CASE("ConstrutorsEnsureZ")
-    {
+{
     // remove z from literals
     {
         cstring_span<> sp = "hello";
@@ -453,10 +450,10 @@ SUITE(string_span_tests)
 
         delete[] ptr;
     }
-    }
+}
 
-    TEST(Constructors)
+TEST_CASE("Constructors")
-    {
+{
     // creating cstring_span
 
     // from span of a final extent
@@ -748,27 +745,27 @@ SUITE(string_span_tests)
         const string_span<> span = tmp;
         CHECK(span.length() == 5);
     }
-    }
+}
 
-    template <typename T>
+template <typename T>
-    T move_wrapper(T && t)
+T move_wrapper(T && t)
-    {
+{
     return std::move(t);
-    }
+}
 
-    template <class T>
+template <class T>
-    T create()
+T create()
-    {
+{
     return T{};
-    }
+}
 
-    template <class T>
+template <class T>
-    void use(basic_string_span<T, gsl::dynamic_extent>)
+void use(basic_string_span<T, gsl::dynamic_extent>)
-    {
+{
-    }
+}
 
-    TEST(MoveConstructors)
+TEST_CASE("MoveConstructors")
-    {
+{
     // move string_span
     {
         cstring_span<> span = "Hello";
@@ -839,19 +836,19 @@ SUITE(string_span_tests)
         use<char>(create<std::vector<char>>());
 #endif
     }
-    }
+}
 
-    TEST(Conversion)
+TEST_CASE("Conversion")
-    {
+{
 #ifdef CONFIRM_COMPILATION_ERRORS
     cstring_span<> span = "Hello";
     cwstring_span<> wspan{span};
     CHECK(wspan.length() == 5);
 #endif
-    }
+}
 
-    czstring_span<> CreateTempName(string_span<> span)
+czstring_span<> CreateTempName(string_span<> span)
-    {
+{
     Expects(span.size() > 1);
 
     int last = 0;
@@ -865,10 +862,10 @@ SUITE(string_span_tests)
 
     auto ret = span.subspan(0, 4);
     return {ret};
-    }
+}
 
-    TEST(zstring)
+TEST_CASE("zstring")
-    {
+{
 
     // create zspan from zero terminated string
     {
@@ -888,7 +885,7 @@ SUITE(string_span_tests)
         buf[0] = 'a';
 
         auto workaround_macro = [&]() { zstring_span<> zspan({buf, 1}); };
-            CHECK_THROW(workaround_macro(), fail_fast);
+        CHECK_THROWS_AS(workaround_macro(), fail_fast);
     }
 
     // usage scenario: create zero-terminated temp file name and pass to a legacy API
@@ -902,10 +899,10 @@ SUITE(string_span_tests)
             CHECK(*(str + 3) == '\0');
         }
     }
-    }
+}
 
-    cwzstring_span<> CreateTempNameW(wstring_span<> span)
+cwzstring_span<> CreateTempNameW(wstring_span<> span)
-    {
+{
     Expects(span.size() > 1);
 
     int last = 0;
@@ -919,10 +916,10 @@ SUITE(string_span_tests)
 
     auto ret = span.subspan(0, 4);
     return {ret};
-    }
+}
 
-    TEST(wzstring)
+TEST_CASE("wzstring")
-    {
+{
 
     // create zspan from zero terminated string
     {
@@ -942,7 +939,7 @@ SUITE(string_span_tests)
         buf[0] = L'a';
 
         const auto workaround_macro = [&]() { wzstring_span<> zspan({buf, 1}); };
-            CHECK_THROW(workaround_macro(), fail_fast);
+        CHECK_THROWS_AS(workaround_macro(), fail_fast);
     }
 
     // usage scenario: create zero-terminated temp file name and pass to a legacy API
@@ -956,14 +953,11 @@ SUITE(string_span_tests)
             CHECK(*(str + 3) == L'\0');
         }
     }
-    }
+}
 
-    TEST(Issue305)
+TEST_CASE("Issue305")
-    {
+{
     std::map<gsl::cstring_span<>, int> foo = {{"foo", 0}, {"bar", 1}};
     CHECK(foo["foo"] == 0);
     CHECK(foo["bar"] == 1);
-    }
 }
-
-int main(int, const char* []) { return UnitTest::RunAllTests(); }

tests/test.cpp

@@ -0,0 +1,18 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define CATCH_CONFIG_MAIN
+#include <catch/catch.hpp>

tests/unittest-cpp

@@ -1 +0,0 @@
-Subproject commit c331bb0deaaf92659a31887c029ee34cac2ab19e

tests/utils_tests.cpp

@@ -14,7 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <UnitTest++/UnitTest++.h>
+#include <catch/catch.hpp>
 
 #include <gsl/gsl>
 
@@ -22,22 +22,20 @@
 
 using namespace gsl;
 
-SUITE(utils_tests)
+void f(int& i) { i += 1; }
-{
-    void f(int& i) { i += 1; }
 
-    TEST(finally_lambda)
+TEST_CASE("finally_lambda")
-    {
+{
     int i = 0;
     {
         auto _ = finally([&]() { f(i); });
         CHECK(i == 0);
     }
     CHECK(i == 1);
-    }
+}
 
-    TEST(finally_lambda_move)
+TEST_CASE("finally_lambda_move")
-    {
+{
     int i = 0;
     {
         auto _1 = finally([&]() { f(i); });
@@ -53,32 +51,32 @@ SUITE(utils_tests)
         CHECK(i == 1);
     }
     CHECK(i == 1);
-    }
+}
 
-    TEST(finally_function_with_bind)
+TEST_CASE("finally_function_with_bind")
-    {
+{
     int i = 0;
     {
         auto _ = finally(std::bind(&f, std::ref(i)));
         CHECK(i == 0);
     }
     CHECK(i == 1);
-    }
+}
 
-    int j = 0;
+int j = 0;
-    void g() { j += 1; }
+void g() { j += 1; }
-    TEST(finally_function_ptr)
+TEST_CASE("finally_function_ptr")
-    {
+{
     j = 0;
     {
         auto _ = finally(&g);
         CHECK(j == 0);
     }
     CHECK(j == 1);
-    }
+}
 
-    TEST(narrow_cast)
+TEST_CASE("narrow_cast")
-    {
+{
     int n = 120;
     char c = narrow_cast<char>(n);
     CHECK(c == 120);
@@ -86,16 +84,16 @@ SUITE(utils_tests)
     n = 300;
     unsigned char uc = narrow_cast<unsigned char>(n);
     CHECK(uc == 44);
-    }
+}
 
-    TEST(narrow)
+TEST_CASE("narrow")
-    {
+{
     int n = 120;
     const char c = narrow<char>(n);
     CHECK(c == 120);
 
     n = 300;
-        CHECK_THROW(narrow<char>(n), narrowing_error);
+    CHECK_THROWS_AS(narrow<char>(n), narrowing_error);
 
     const auto int32_max = std::numeric_limits<int32_t>::max();
     const auto int32_min = std::numeric_limits<int32_t>::min();
@@ -104,12 +102,9 @@ SUITE(utils_tests)
     CHECK(narrow<uint32_t>(int32_t(1)) == 1);
     CHECK(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
 
-        CHECK_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
+    CHECK_THROWS_AS(narrow<uint32_t>(int32_t(-1)), narrowing_error);
-        CHECK_THROW(narrow<uint32_t>(int32_min), narrowing_error);
+    CHECK_THROWS_AS(narrow<uint32_t>(int32_min), narrowing_error);
 
     n = -42;
-        CHECK_THROW(narrow<unsigned>(n), narrowing_error);
+    CHECK_THROWS_AS(narrow<unsigned>(n), narrowing_error);
-    }
 }
-
-int main(int, const char* []) { return UnitTest::RunAllTests(); }