mirror of
https://github.com/microsoft/GSL.git
synced 2024-11-03 17:56:43 -05:00
Move from unittest-cpp to catch for unit testing. (#533)
Many thanks to @rianquinn. This should fix #495, #494 and #529.
This commit is contained in:
Neil MacIntosh
GitHub
parent
1f87ef73f1
commit
b2ee484334
2
.gitignore
vendored
2
.gitignore
vendored
@ -1,4 +1,6 @@
|
||||
CMakeFiles
|
||||
build
|
||||
include/catch
|
||||
tests/CMakeFiles
|
||||
tests/Debug
|
||||
*.opensdf
|
||||
|
||||
3
.gitmodules
vendored
3
.gitmodules
vendored
@ -1,3 +0,0 @@
|
||||
[submodule "tests/unittest-cpp"]
|
||||
path = tests/unittest-cpp
|
||||
url = https://github.com/unittest-cpp/unittest-cpp.git
|
||||
17
.travis.yml
17
.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"
|
||||
|
||||
@ -1,13 +1,16 @@
|
||||
cmake_minimum_required(VERSION 2.8.7)
|
||||
cmake_minimum_required(VERSION 3.1.3)
|
||||
|
||||
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)
|
||||
|
||||
@ -17,6 +17,9 @@ other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more inform
|
||||
# Project Code of Conduct
|
||||
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
|
||||
|
||||
# Usage of Third Party Libraries
|
||||
This project makes use of the [Catch](https://github.com/philsquared/catch) testing library. Please see the [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) file for details regarding the licensing of Catch.
|
||||
|
||||
# Quick Start
|
||||
## Supported Platforms
|
||||
The test suite that exercises GSL has been built and passes successfully on the following platforms:<sup>1)</sup>
|
||||
@ -40,9 +43,7 @@ contributing any changes that were necessary back to this project to benefit the
|
||||
## Building the tests
|
||||
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.
|
||||
* [CMake](http://cmake.org), version 3.1.3 or later to be installed and in your PATH.
|
||||
|
||||
These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.
|
||||
|
||||
|
||||
39
ThirdPartyNotices.txt
Normal file
39
ThirdPartyNotices.txt
Normal file
@ -0,0 +1,39 @@
|
||||
|
||||
THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
|
||||
Do Not Translate or Localize
|
||||
|
||||
GSL: Guideline Support Library incorporates third party material from the projects listed below. The original copyright notice and the license under which Microsoft received such third party material are set forth below. Microsoft reserves all other rights not expressly granted, whether by implication, estoppel or otherwise.
|
||||
|
||||
|
||||
1. Catch (https://github.com/philsquared/Catch)
|
||||
|
||||
|
||||
%% Catch NOTICES, INFORMATION, AND LICENSE BEGIN HERE
|
||||
=========================================
|
||||
Boost Software License - Version 1.0 - August 17th, 2003
|
||||
|
||||
Permission is hereby granted, free of charge, to any person or organization
|
||||
obtaining a copy of the software and accompanying documentation covered by
|
||||
this license (the "Software") to use, reproduce, display, distribute,
|
||||
execute, and transmit the Software, and to prepare derivative works of the
|
||||
Software, and to permit third-parties to whom the Software is furnished to
|
||||
do so, all subject to the following:
|
||||
|
||||
The copyright notices in the Software and this entire statement, including
|
||||
the above license grant, this restriction and the following disclaimer,
|
||||
must be included in all copies of the Software, in whole or in part, and
|
||||
all derivative works of the Software, unless such copies or derivative
|
||||
works are solely in the form of machine-executable object code generated by
|
||||
a source language processor.
|
||||
|
||||
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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
=========================================
|
||||
END OF Catch NOTICES, INFORMATION, AND LICENSE
|
||||
|
||||
|
||||
11
appveyor.yml
11
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")) {
|
||||
Start-FileDownload 'https://cmake.org/files/v3.7/cmake-3.7.2-win32-x86.zip'
|
||||
7z x -y cmake-3.7.2-win32-x86.zip -oC:\
|
||||
if (![IO.File]::Exists("C:\cmake-3.8.0-win32-x86\bin\cmake.exe")) {
|
||||
Start-FileDownload 'https://cmake.org/files/v3.8/cmake-3.8.0-win32-x86.zip'
|
||||
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: |
|
||||
|
||||
@ -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")
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -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)
|
||||
find_package(Git)
|
||||
execute_process(
|
||||
COMMAND ${GIT_EXECUTABLE} submodule update --init
|
||||
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
)
|
||||
endif()
|
||||
list(APPEND CATCH_CMAKE_ARGS
|
||||
"-DCMAKE_INSTALL_PREFIX=${CMAKE_SOURCE_DIR}"
|
||||
"-DNO_SELFTEST=true"
|
||||
)
|
||||
|
||||
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.6
|
||||
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}
|
||||
|
||||
@ -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_THROW(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_dyn, dst_span_dyn), fail_fast);
|
||||
CHECK_THROWS_AS(copy(src_span_dyn, dst_span_static), 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(); }
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
@ -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_THROW(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROW(gsl::at(c_a, -1), fail_fast);
|
||||
CHECK_THROW(gsl::at(c_a, 4), fail_fast);
|
||||
}
|
||||
CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(c_a, -1), 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_THROW(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROW(gsl::at(c_a, -1), fail_fast);
|
||||
CHECK_THROW(gsl::at(c_a, 4), fail_fast);
|
||||
}
|
||||
CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(c_a, -1), 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_THROW(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROW(gsl::at(c_a, -1), fail_fast);
|
||||
CHECK_THROW(gsl::at(c_a, 4), fail_fast);
|
||||
}
|
||||
CHECK_THROWS_AS(gsl::at(a, -1), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(c_a, -1), 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_THROW(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROW(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(a, -1), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at(a, 4), fail_fast);
|
||||
CHECK_THROWS_AS(gsl::at({1, 2, 3, 4}, -1), 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(); }
|
||||
|
||||
@ -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(); }
|
||||
|
||||
@ -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(); }
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -14,7 +14,7 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/gsl>
|
||||
|
||||
@ -104,14 +104,10 @@ struct NonCopyableNonMovable
|
||||
NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
|
||||
};
|
||||
|
||||
bool helper(not_null<int*> p) { return *p == 12; }
|
||||
|
||||
SUITE(NotNullTests)
|
||||
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!
|
||||
@ -131,10 +127,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;
|
||||
@ -154,20 +150,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];
|
||||
@ -193,13 +189,40 @@ SUITE(NotNullTests)
|
||||
CHECK((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
|
||||
CHECK((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
|
||||
|
||||
CHECK((NotNull1(p1) >= NotNull1(p1)) == true);
|
||||
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
|
||||
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullDereferenceOperator")
|
||||
{
|
||||
{
|
||||
auto sp1 = std::make_shared<NonCopyableNonMovable>();
|
||||
|
||||
using NotNullSp1 = not_null<decltype(sp1)>;
|
||||
CHECK(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
|
||||
CHECK(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
|
||||
}
|
||||
|
||||
TEST(TestNotNullSharedPtrComparison)
|
||||
{
|
||||
int ints[1] = { 42 };
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
CHECK(typeid(*NotNull1(p1)) == typeid(*p1));
|
||||
CHECK(*NotNull1(p1) == 42);
|
||||
*NotNull1(p1) = 43;
|
||||
CHECK(ints[0] == 43);
|
||||
}
|
||||
|
||||
{
|
||||
int v = 42;
|
||||
gsl::not_null<int*> p(&v);
|
||||
CHECK(typeid(*p) == typeid(*(&v)));
|
||||
*p = 43;
|
||||
CHECK(v == 43);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullSharedPtrComparison")
|
||||
{
|
||||
auto sp1 = std::make_shared<int>(42);
|
||||
auto sp2 = std::make_shared<const int>(43);
|
||||
|
||||
@ -227,10 +250,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]);
|
||||
@ -259,37 +282,4 @@ SUITE(NotNullTests)
|
||||
CHECK((NotNull1(p1) >= NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
|
||||
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
|
||||
}
|
||||
|
||||
TEST(TestNotNullDereferenceOperator)
|
||||
{
|
||||
{
|
||||
auto sp1 = std::make_shared<NonCopyableNonMovable>();
|
||||
|
||||
using NotNullSp1 = not_null<decltype(sp1)>;
|
||||
CHECK(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
|
||||
CHECK(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
|
||||
}
|
||||
|
||||
{
|
||||
int ints[1] = { 42 };
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
CHECK(typeid(*NotNull1(p1)) == typeid(*p1));
|
||||
CHECK(*NotNull1(p1) == 42);
|
||||
*NotNull1(p1) = 43;
|
||||
CHECK(ints[0] == 43);
|
||||
}
|
||||
|
||||
{
|
||||
int v = 42;
|
||||
gsl::not_null<int*> p(&v);
|
||||
CHECK(typeid(*p) == typeid(*(&v)));
|
||||
*p = 43;
|
||||
CHECK(v == 43);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(int, const char* []) { return UnitTest::RunAllTests(); }
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/gsl>
|
||||
|
||||
@ -24,28 +24,23 @@
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(check_pointer_constraint)
|
||||
{
|
||||
TEST_CASE("check_pointer_constraint")
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
{
|
||||
owner<int> integerTest = 10;
|
||||
owner<std::shared_ptr<int>> sharedPtrTest(new int(10));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
int main(int, const char* []) { return UnitTest::RunAllTests(); }
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -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_THROW(av.section(1, 0)[0], fail_fast);
|
||||
CHECK_THROW(av.section(1, 1)[1], fail_fast);
|
||||
CHECK_THROWS_AS(av.section(0, 0)[0], fail_fast);
|
||||
CHECK_THROWS_AS(av.section(1, 0)[0], fail_fast);
|
||||
CHECK_THROWS_AS(av.section(1, 1)[1], fail_fast);
|
||||
|
||||
CHECK_THROW(av.section(2, 5), fail_fast);
|
||||
CHECK_THROW(av.section(5, 2), fail_fast);
|
||||
CHECK_THROW(av.section(5, 0), fail_fast);
|
||||
CHECK_THROW(av.section(0, 5), fail_fast);
|
||||
CHECK_THROW(av.section(5, 5), fail_fast);
|
||||
CHECK_THROWS_AS(av.section(2, 5), fail_fast);
|
||||
CHECK_THROWS_AS(av.section(5, 2), fail_fast);
|
||||
CHECK_THROWS_AS(av.section(5, 0), fail_fast);
|
||||
CHECK_THROWS_AS(av.section(0, 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_THROW((strided_span<int, 1>{arr, {3, 3}}), fail_fast);
|
||||
CHECK_THROW((strided_span<int, 1>{arr, {4, 5}}), fail_fast);
|
||||
CHECK_THROW((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, {3, 2}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{arr, {3, 3}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{arr, {4, 5}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{arr, {5, 1}}), 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_THROW((strided_span<int, 1>{av, {3, 3}}), fail_fast);
|
||||
CHECK_THROW((strided_span<int, 1>{av, {4, 5}}), fail_fast);
|
||||
CHECK_THROW((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, {3, 2}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av, {3, 3}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av, {4, 5}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av, {5, 1}}), 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_THROW((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_THROW((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_THROW((strided_span<int, 1>{av.data(), 2, {2, 2}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {3, 2}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {3, 3}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {4, 5}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {5, 1}}), fail_fast);
|
||||
CHECK_THROWS_AS((strided_span<int, 1>{av.data(), 4, {5, 5}}), 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_THROW(sav3[0][1], fail_fast);
|
||||
CHECK_THROWS_AS(sav3[1][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_THROW(sav3[0][1], fail_fast);
|
||||
CHECK_THROWS_AS(sav3[1][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_THROW(empty_sav.begin()[0], fail_fast);
|
||||
CHECK_THROW(empty_sav.cbegin()[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_sav[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_sav.begin()[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_THROW(empty_sav.begin()[0], fail_fast);
|
||||
CHECK_THROW(empty_sav.cbegin()[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_sav[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_sav.begin()[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(); }
|
||||
|
||||
@ -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>
|
||||
T move_wrapper(T && t)
|
||||
{
|
||||
template <typename T>
|
||||
T move_wrapper(T && t)
|
||||
{
|
||||
return std::move(t);
|
||||
}
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T create()
|
||||
{
|
||||
template <class T>
|
||||
T create()
|
||||
{
|
||||
return T{};
|
||||
}
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void use(basic_string_span<T, gsl::dynamic_extent>)
|
||||
{
|
||||
}
|
||||
template <class T>
|
||||
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(); }
|
||||
|
||||
18
tests/test.cpp
Normal file
18
tests/test.cpp
Normal file
@ -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>
|
||||
@ -1 +0,0 @@
|
||||
Subproject commit c331bb0deaaf92659a31887c029ee34cac2ab19e
|
||||
@ -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;
|
||||
void g() { j += 1; }
|
||||
TEST(finally_function_ptr)
|
||||
{
|
||||
int j = 0;
|
||||
void g() { j += 1; }
|
||||
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_THROW(narrow<uint32_t>(int32_min), narrowing_error);
|
||||
CHECK_THROWS_AS(narrow<uint32_t>(int32_t(-1)), 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(); }
|
||||
|
||||
Loading…
Reference in New Issue
Block a user