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,7 +1,10 @@
|
||||
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)
|
||||
|
||||
|
||||
@ -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}"
|
||||
list(APPEND CATCH_CMAKE_ARGS
|
||||
"-DCMAKE_INSTALL_PREFIX=${CMAKE_SOURCE_DIR}"
|
||||
"-DNO_SELFTEST=true"
|
||||
)
|
||||
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.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
|
||||
)
|
||||
|
||||
function(add_gsl_test name)
|
||||
add_executable(${name} ${name}.cpp)
|
||||
target_link_libraries(${name}
|
||||
UnitTest++
|
||||
# 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}
|
||||
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,10 +23,7 @@
|
||||
using namespace std;
|
||||
using namespace gsl;
|
||||
|
||||
SUITE(copy_tests)
|
||||
{
|
||||
|
||||
TEST(same_type)
|
||||
TEST_CASE("same_type")
|
||||
{
|
||||
// dynamic source and destination span
|
||||
{
|
||||
@ -97,7 +94,7 @@ SUITE(copy_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(compatible_type)
|
||||
TEST_CASE("compatible_type")
|
||||
{
|
||||
// dynamic source and destination span
|
||||
{
|
||||
@ -169,7 +166,7 @@ SUITE(copy_tests)
|
||||
}
|
||||
|
||||
#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{};
|
||||
@ -187,7 +184,7 @@ SUITE(copy_tests)
|
||||
}
|
||||
#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,24 +14,22 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/gsl>
|
||||
|
||||
using namespace gsl;
|
||||
|
||||
SUITE(assertion_tests)
|
||||
{
|
||||
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)
|
||||
@ -41,11 +39,8 @@ SUITE(assertion_tests)
|
||||
return i;
|
||||
}
|
||||
|
||||
TEST(ensures)
|
||||
TEST_CASE("ensures")
|
||||
{
|
||||
CHECK(g(2) == 3);
|
||||
CHECK_THROW(g(9), fail_fast);
|
||||
CHECK_THROWS_AS(g(9), fail_fast);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int, const char* []) { return UnitTest::RunAllTests(); }
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/gsl>
|
||||
|
||||
@ -23,9 +23,7 @@
|
||||
|
||||
using gsl::fail_fast;
|
||||
|
||||
SUITE(at_tests)
|
||||
{
|
||||
TEST(static_array)
|
||||
TEST_CASE("static_array")
|
||||
{
|
||||
int a[4] = {1, 2, 3, 4};
|
||||
const int(&c_a)[4] = a;
|
||||
@ -35,13 +33,13 @@ 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,13 +49,13 @@ 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,13 +65,13 @@ 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};
|
||||
|
||||
@ -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,9 +28,7 @@ namespace
|
||||
void use(std::ptrdiff_t&) {}
|
||||
}
|
||||
|
||||
SUITE(bounds_test)
|
||||
{
|
||||
TEST(basic_bounds)
|
||||
TEST_CASE("basic_bounds")
|
||||
{
|
||||
for (auto point : static_bounds<dynamic_range, 3, 4>{2}) {
|
||||
for (decltype(point)::size_type j = 0;
|
||||
@ -42,7 +40,7 @@ SUITE(bounds_test)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(bounds_basic)
|
||||
TEST_CASE("bounds_basic")
|
||||
{
|
||||
static_bounds<3, 4, 5> b;
|
||||
const auto a = b.slice();
|
||||
@ -51,7 +49,7 @@ SUITE(bounds_test)
|
||||
x.slice().slice();
|
||||
}
|
||||
|
||||
TEST(arrayview_iterator)
|
||||
TEST_CASE("arrayview_iterator")
|
||||
{
|
||||
static_bounds<4, dynamic_range, 2> bounds{3};
|
||||
|
||||
@ -69,7 +67,7 @@ SUITE(bounds_test)
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(bounds_convertible)
|
||||
TEST_CASE("bounds_convertible")
|
||||
{
|
||||
static_bounds<7, 4, 2> b1;
|
||||
static_bounds<7, dynamic_range, 2> b2 = b1;
|
||||
@ -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,9 +31,7 @@ using namespace gsl;
|
||||
namespace
|
||||
{
|
||||
|
||||
SUITE(byte_tests)
|
||||
{
|
||||
TEST(construction)
|
||||
TEST_CASE("construction")
|
||||
{
|
||||
{
|
||||
const byte b = static_cast<byte>(4);
|
||||
@ -62,7 +60,7 @@ SUITE(byte_tests)
|
||||
//}
|
||||
}
|
||||
|
||||
TEST(bitwise_operations)
|
||||
TEST_CASE("bitwise_operations")
|
||||
{
|
||||
const byte b = to_byte<0xFF>();
|
||||
|
||||
@ -98,7 +96,7 @@ SUITE(byte_tests)
|
||||
CHECK(a == to_byte<0x0F>());
|
||||
}
|
||||
|
||||
TEST(to_integer)
|
||||
TEST_CASE("to_integer")
|
||||
{
|
||||
const byte b = to_byte<0x12>();
|
||||
|
||||
@ -123,13 +121,11 @@ SUITE(byte_tests)
|
||||
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(); }
|
||||
}
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/multi_span>
|
||||
|
||||
@ -38,146 +38,143 @@ struct DerivedClass : BaseClass
|
||||
};
|
||||
}
|
||||
|
||||
SUITE(multi_span_tests)
|
||||
{
|
||||
|
||||
TEST(default_constructor)
|
||||
TEST_CASE("default_constructor")
|
||||
{
|
||||
{
|
||||
multi_span<int> s;
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int> cs;
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s;
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int, 0> cs;
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<int, 1> s;
|
||||
CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
|
||||
CHECK((s.length() == 1 && s.data() == nullptr)); // explains why it can't compile
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int> s{};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int> cs{};
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_nullptr_constructor)
|
||||
TEST_CASE("from_nullptr_constructor")
|
||||
{
|
||||
{
|
||||
multi_span<int> s = nullptr;
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int> cs = nullptr;
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s = nullptr;
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int, 0> cs = nullptr;
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<int, 1> s = nullptr;
|
||||
CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
|
||||
CHECK((s.length() == 1 && s.data() == nullptr)); // explains why it can't compile
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int> s{nullptr};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int> cs{nullptr};
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int*> s{nullptr};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int*> cs{nullptr};
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_nullptr_length_constructor)
|
||||
TEST_CASE("from_nullptr_length_constructor")
|
||||
{
|
||||
{
|
||||
multi_span<int> s{nullptr, 0};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int> cs{nullptr, 0};
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s{nullptr, 0};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int, 0> cs{nullptr, 0};
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<int, 1> s{nullptr, 0};
|
||||
CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile
|
||||
CHECK((s.length() == 1 && s.data() == nullptr)); // explains why it can't compile
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
auto workaround_macro = []() { multi_span<int> s{nullptr, 1}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
|
||||
auto const_workaround_macro = []() { multi_span<const int> cs{nullptr, 1}; };
|
||||
CHECK_THROW(const_workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(const_workaround_macro(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
auto workaround_macro = []() { multi_span<int, 0> s{nullptr, 1}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
|
||||
auto const_workaround_macro = []() { multi_span<const int, 0> s{nullptr, 1}; };
|
||||
CHECK_THROW(const_workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(const_workaround_macro(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int*> s{nullptr, 0};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
|
||||
multi_span<const int*> cs{nullptr, 0};
|
||||
CHECK(cs.length() == 0 && cs.data() == nullptr);
|
||||
CHECK((cs.length() == 0 && cs.data() == nullptr));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_element_constructor)
|
||||
TEST_CASE("from_element_constructor")
|
||||
{
|
||||
int i = 5;
|
||||
|
||||
{
|
||||
multi_span<int> s = i;
|
||||
CHECK(s.length() == 1 && s.data() == &i);
|
||||
CHECK((s.length() == 1 && s.data() == &i));
|
||||
CHECK(s[0] == 5);
|
||||
|
||||
multi_span<const int> cs = i;
|
||||
CHECK(cs.length() == 1 && cs.data() == &i);
|
||||
CHECK((cs.length() == 1 && cs.data() == &i));
|
||||
CHECK(cs[0] == 5);
|
||||
}
|
||||
|
||||
@ -191,20 +188,20 @@ SUITE(multi_span_tests)
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<int, 0> s = i;
|
||||
CHECK(s.length() == 0 && s.data() == &i);
|
||||
CHECK((s.length() == 0 && s.data() == &i));
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 1> s = i;
|
||||
CHECK(s.length() == 1 && s.data() == &i);
|
||||
CHECK((s.length() == 1 && s.data() == &i));
|
||||
CHECK(s[0] == 5);
|
||||
}
|
||||
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<int, 2> s = i;
|
||||
CHECK(s.length() == 2 && s.data() == &i);
|
||||
CHECK((s.length() == 2 && s.data() == &i));
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -217,97 +214,97 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_pointer_length_constructor)
|
||||
TEST_CASE("from_pointer_length_constructor")
|
||||
{
|
||||
int arr[4] = {1, 2, 3, 4};
|
||||
|
||||
{
|
||||
multi_span<int> s{&arr[0], 2};
|
||||
CHECK(s.length() == 2 && s.data() == &arr[0]);
|
||||
CHECK(s[0] == 1 && s[1] == 2);
|
||||
CHECK((s.length() == 2 && s.data() == &arr[0]));
|
||||
CHECK((s[0] == 1 && s[1] == 2));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 2> s{&arr[0], 2};
|
||||
CHECK(s.length() == 2 && s.data() == &arr[0]);
|
||||
CHECK(s[0] == 1 && s[1] == 2);
|
||||
CHECK((s.length() == 2 && s.data() == &arr[0]));
|
||||
CHECK((s[0] == 1 && s[1] == 2));
|
||||
}
|
||||
|
||||
{
|
||||
int* p = nullptr;
|
||||
multi_span<int> s{p, 0};
|
||||
CHECK(s.length() == 0 && s.data() == nullptr);
|
||||
CHECK((s.length() == 0 && s.data() == nullptr));
|
||||
}
|
||||
|
||||
{
|
||||
int* p = nullptr;
|
||||
auto workaround_macro = [=]() { multi_span<int> s{p, 2}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_pointer_pointer_constructor)
|
||||
TEST_CASE("from_pointer_pointer_constructor")
|
||||
{
|
||||
int arr[4] = {1, 2, 3, 4};
|
||||
|
||||
{
|
||||
multi_span<int> s{&arr[0], &arr[2]};
|
||||
CHECK(s.length() == 2 && s.data() == &arr[0]);
|
||||
CHECK(s[0] == 1 && s[1] == 2);
|
||||
CHECK((s.length() == 2 && s.data() == &arr[0]));
|
||||
CHECK((s[0] == 1 && s[1] == 2));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 2> s{&arr[0], &arr[2]};
|
||||
CHECK(s.length() == 2 && s.data() == &arr[0]);
|
||||
CHECK(s[0] == 1 && s[1] == 2);
|
||||
CHECK((s.length() == 2 && s.data() == &arr[0]));
|
||||
CHECK((s[0] == 1 && s[1] == 2));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int> s{&arr[0], &arr[0]};
|
||||
CHECK(s.length() == 0 && s.data() == &arr[0]);
|
||||
CHECK((s.length() == 0 && s.data() == &arr[0]));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s{&arr[0], &arr[0]};
|
||||
CHECK(s.length() == 0 && s.data() == &arr[0]);
|
||||
CHECK((s.length() == 0 && s.data() == &arr[0]));
|
||||
}
|
||||
|
||||
{
|
||||
auto workaround_macro = [&]() { multi_span<int> s{&arr[1], &arr[0]}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
int* p = nullptr;
|
||||
auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
int* p = nullptr;
|
||||
auto workaround_macro = [&]() { multi_span<int> s{p, p}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
int* p = nullptr;
|
||||
auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; };
|
||||
CHECK_THROW(workaround_macro(), fail_fast);
|
||||
CHECK_THROWS_AS(workaround_macro(), fail_fast);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_array_constructor)
|
||||
TEST_CASE("from_array_constructor")
|
||||
{
|
||||
int arr[5] = {1, 2, 3, 4, 5};
|
||||
|
||||
{
|
||||
multi_span<int> s{arr};
|
||||
CHECK(s.length() == 5 && s.data() == &arr[0]);
|
||||
CHECK((s.length() == 5 && s.data() == &arr[0]));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 5> s{arr};
|
||||
CHECK(s.length() == 5 && s.data() == &arr[0]);
|
||||
CHECK((s.length() == 5 && s.data() == &arr[0]));
|
||||
}
|
||||
|
||||
{
|
||||
@ -318,20 +315,20 @@ SUITE(multi_span_tests)
|
||||
|
||||
{
|
||||
multi_span<int, 0> s{arr};
|
||||
CHECK(s.length() == 0 && s.data() == &arr[0]);
|
||||
CHECK((s.length() == 0 && s.data() == &arr[0]));
|
||||
}
|
||||
|
||||
int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
|
||||
|
||||
{
|
||||
multi_span<int> s{arr2d};
|
||||
CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
|
||||
CHECK(s[0] == 1 && s[5] == 6);
|
||||
CHECK((s.length() == 6 && s.data() == &arr2d[0][0]));
|
||||
CHECK((s[0] == 1 && s[5] == 6));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s{arr2d};
|
||||
CHECK(s.length() == 0 && s.data() == &arr2d[0][0]);
|
||||
CHECK((s.length() == 0 && s.data() == &arr2d[0][0]));
|
||||
}
|
||||
|
||||
{
|
||||
@ -342,8 +339,8 @@ SUITE(multi_span_tests)
|
||||
|
||||
{
|
||||
multi_span<int, 6> s{arr2d};
|
||||
CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
|
||||
CHECK(s[0] == 1 && s[5] == 6);
|
||||
CHECK((s.length() == 6 && s.data() == &arr2d[0][0]));
|
||||
CHECK((s[0] == 1 && s[5] == 6));
|
||||
}
|
||||
|
||||
{
|
||||
@ -354,12 +351,12 @@ SUITE(multi_span_tests)
|
||||
|
||||
{
|
||||
multi_span<int[3]> s{arr2d[0]};
|
||||
CHECK(s.length() == 1 && s.data() == &arr2d[0]);
|
||||
CHECK((s.length() == 1 && s.data() == &arr2d[0]));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 2, 3> s{arr2d};
|
||||
CHECK(s.length() == 6 && s.data() == &arr2d[0][0]);
|
||||
CHECK((s.length() == 6 && s.data() == &arr2d[0][0]));
|
||||
auto workaround_macro = [&]() { return s[{1, 2}] == 6; };
|
||||
CHECK(workaround_macro());
|
||||
}
|
||||
@ -374,13 +371,13 @@ SUITE(multi_span_tests)
|
||||
|
||||
{
|
||||
multi_span<int> s{arr3d};
|
||||
CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
|
||||
CHECK(s[0] == 1 && s[11] == 12);
|
||||
CHECK((s.length() == 12 && s.data() == &arr3d[0][0][0]));
|
||||
CHECK((s[0] == 1 && s[11] == 12));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s{arr3d};
|
||||
CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]);
|
||||
CHECK((s.length() == 0 && s.data() == &arr3d[0][0][0]));
|
||||
}
|
||||
|
||||
{
|
||||
@ -391,8 +388,8 @@ SUITE(multi_span_tests)
|
||||
|
||||
{
|
||||
multi_span<int, 12> s{arr3d};
|
||||
CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
|
||||
CHECK(s[0] == 1 && s[5] == 6);
|
||||
CHECK((s.length() == 12 && s.data() == &arr3d[0][0][0]));
|
||||
CHECK((s[0] == 1 && s[5] == 6));
|
||||
}
|
||||
|
||||
{
|
||||
@ -403,12 +400,12 @@ SUITE(multi_span_tests)
|
||||
|
||||
{
|
||||
multi_span<int[3][2]> s{arr3d[0]};
|
||||
CHECK(s.length() == 1 && s.data() == &arr3d[0]);
|
||||
CHECK((s.length() == 1 && s.data() == &arr3d[0]));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 3, 2, 2> s{arr3d};
|
||||
CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]);
|
||||
CHECK((s.length() == 12 && s.data() == &arr3d[0][0][0]));
|
||||
auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; };
|
||||
CHECK(workaround_macro());
|
||||
}
|
||||
@ -420,68 +417,68 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_dynamic_array_constructor)
|
||||
TEST_CASE("from_dynamic_array_constructor")
|
||||
{
|
||||
double(*arr)[3][4] = new double[100][3][4];
|
||||
|
||||
{
|
||||
multi_span<double, dynamic_range, 3, 4> s(arr, 10);
|
||||
CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
|
||||
CHECK_THROW(s[10][3][4], fail_fast);
|
||||
CHECK((s.length() == 120 && s.data() == &arr[0][0][0]));
|
||||
CHECK_THROWS_AS(s[10][3][4], fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<double, dynamic_range, 4, 3> s(arr, 10);
|
||||
CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
|
||||
CHECK((s.length() == 120 && s.data() == &arr[0][0][0]));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<double> s(arr, 10);
|
||||
CHECK(s.length() == 120 && s.data() == &arr[0][0][0]);
|
||||
CHECK((s.length() == 120 && s.data() == &arr[0][0][0]));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<double, dynamic_range, 3, 4> s(arr, 0);
|
||||
CHECK(s.length() == 0 && s.data() == &arr[0][0][0]);
|
||||
CHECK((s.length() == 0 && s.data() == &arr[0][0][0]));
|
||||
}
|
||||
|
||||
delete[] arr;
|
||||
}
|
||||
|
||||
TEST(from_std_array_constructor)
|
||||
TEST_CASE("from_std_array_constructor")
|
||||
{
|
||||
std::array<int, 4> arr = {1, 2, 3, 4};
|
||||
|
||||
{
|
||||
multi_span<int> s{arr};
|
||||
CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
|
||||
CHECK((s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()));
|
||||
|
||||
multi_span<const int> cs{arr};
|
||||
CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
|
||||
CHECK((cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 4> s{arr};
|
||||
CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
|
||||
CHECK((s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()));
|
||||
|
||||
multi_span<const int, 4> cs{arr};
|
||||
CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data());
|
||||
CHECK((cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 2> s{arr};
|
||||
CHECK(s.size() == 2 && s.data() == arr.data());
|
||||
CHECK((s.size() == 2 && s.data() == arr.data()));
|
||||
|
||||
multi_span<const int, 2> cs{arr};
|
||||
CHECK(cs.size() == 2 && cs.data() == arr.data());
|
||||
CHECK((cs.size() == 2 && cs.data() == arr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int, 0> s{arr};
|
||||
CHECK(s.size() == 0 && s.data() == arr.data());
|
||||
CHECK((s.size() == 0 && s.data() == arr.data()));
|
||||
|
||||
multi_span<const int, 0> cs{arr};
|
||||
CHECK(cs.size() == 0 && cs.data() == arr.data());
|
||||
CHECK((cs.size() == 0 && cs.data() == arr.data()));
|
||||
}
|
||||
|
||||
// TODO This is currently an unsupported scenario. We will come back to it as we revise
|
||||
@ -507,28 +504,28 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_const_std_array_constructor)
|
||||
TEST_CASE("from_const_std_array_constructor")
|
||||
{
|
||||
const std::array<int, 4> arr = {1, 2, 3, 4};
|
||||
|
||||
{
|
||||
multi_span<const int> s{arr};
|
||||
CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
|
||||
CHECK((s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<const int, 4> s{arr};
|
||||
CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data());
|
||||
CHECK((s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<const int, 2> s{arr};
|
||||
CHECK(s.size() == 2 && s.data() == arr.data());
|
||||
CHECK((s.size() == 2 && s.data() == arr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<const int, 0> s{arr};
|
||||
CHECK(s.size() == 0 && s.data() == arr.data());
|
||||
CHECK((s.size() == 0 && s.data() == arr.data()));
|
||||
}
|
||||
|
||||
// TODO This is currently an unsupported scenario. We will come back to it as we revise
|
||||
@ -554,17 +551,17 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_container_constructor)
|
||||
TEST_CASE("from_container_constructor")
|
||||
{
|
||||
std::vector<int> v = {1, 2, 3};
|
||||
const std::vector<int> cv = v;
|
||||
|
||||
{
|
||||
multi_span<int> s{v};
|
||||
CHECK(s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data());
|
||||
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data()));
|
||||
|
||||
multi_span<const int> cs{v};
|
||||
CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data());
|
||||
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data()));
|
||||
}
|
||||
|
||||
std::string str = "hello";
|
||||
@ -573,10 +570,10 @@ SUITE(multi_span_tests)
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<char> s{str};
|
||||
CHECK(s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data());
|
||||
CHECK((s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data()));
|
||||
#endif
|
||||
multi_span<const char> cs{str};
|
||||
CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data());
|
||||
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data()));
|
||||
}
|
||||
|
||||
{
|
||||
@ -584,8 +581,8 @@ SUITE(multi_span_tests)
|
||||
multi_span<char> s{cstr};
|
||||
#endif
|
||||
multi_span<const char> cs{cstr};
|
||||
CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) &&
|
||||
cs.data() == cstr.data());
|
||||
CHECK((cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) &&
|
||||
cs.data() == cstr.data()));
|
||||
}
|
||||
|
||||
{
|
||||
@ -628,13 +625,13 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(from_convertible_span_constructor)
|
||||
TEST_CASE("from_convertible_span_constructor")
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
multi_span<int, 7, 4, 2> av1(nullptr, b1);
|
||||
|
||||
auto f = [&]() { multi_span<int, 7, 4, 2> av1(nullptr); };
|
||||
CHECK_THROW(f(), fail_fast);
|
||||
CHECK_THROWS_AS(f(), fail_fast);
|
||||
#endif
|
||||
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
@ -655,7 +652,7 @@ SUITE(multi_span_tests)
|
||||
(void) avcd;
|
||||
}
|
||||
|
||||
TEST(copy_move_and_assignment)
|
||||
TEST_CASE("copy_move_and_assignment")
|
||||
{
|
||||
multi_span<int> s1;
|
||||
CHECK(s1.empty());
|
||||
@ -663,19 +660,19 @@ SUITE(multi_span_tests)
|
||||
int arr[] = {3, 4, 5};
|
||||
|
||||
multi_span<const int> s2 = arr;
|
||||
CHECK(s2.length() == 3 && s2.data() == &arr[0]);
|
||||
CHECK((s2.length() == 3 && s2.data() == &arr[0]));
|
||||
|
||||
s2 = s1;
|
||||
CHECK(s2.empty());
|
||||
|
||||
auto get_temp_span = [&]() -> multi_span<int> { return {&arr[1], 2}; };
|
||||
auto use_span = [&](multi_span<const int> s) {
|
||||
CHECK(s.length() == 2 && s.data() == &arr[1]);
|
||||
CHECK((s.length() == 2 && s.data() == &arr[1]));
|
||||
};
|
||||
use_span(get_temp_span());
|
||||
|
||||
s1 = get_temp_span();
|
||||
CHECK(s1.length() == 2 && s1.data() == &arr[1]);
|
||||
CHECK((s1.length() == 2 && s1.data() == &arr[1]));
|
||||
}
|
||||
|
||||
template <class Bounds>
|
||||
@ -683,7 +680,7 @@ SUITE(multi_span_tests)
|
||||
{
|
||||
static_assert(Bounds::static_size == 60, "static bounds is wrong size");
|
||||
}
|
||||
TEST(as_multi_span_reshape)
|
||||
TEST_CASE("as_multi_span_reshape")
|
||||
{
|
||||
int a[3][4][5];
|
||||
auto av = as_multi_span(a);
|
||||
@ -706,7 +703,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(first)
|
||||
TEST_CASE("first")
|
||||
{
|
||||
int arr[5] = {1, 2, 3, 4, 5};
|
||||
|
||||
@ -738,7 +735,7 @@ SUITE(multi_span_tests)
|
||||
CHECK(av.first<6>().length() == 6);
|
||||
CHECK(av.first<-1>().length() == -1);
|
||||
#endif
|
||||
CHECK_THROW(av.first(6).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.first(6).length(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -749,7 +746,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(last)
|
||||
TEST_CASE("last")
|
||||
{
|
||||
int arr[5] = {1, 2, 3, 4, 5};
|
||||
|
||||
@ -780,7 +777,7 @@ SUITE(multi_span_tests)
|
||||
CHECK((av.last<6>().bounds() == static_bounds<6>()));
|
||||
CHECK(av.last<6>().length() == 6);
|
||||
#endif
|
||||
CHECK_THROW(av.last(6).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.last(6).length(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -791,7 +788,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(subspan)
|
||||
TEST_CASE("subspan")
|
||||
{
|
||||
int arr[5] = {1, 2, 3, 4, 5};
|
||||
|
||||
@ -815,8 +812,8 @@ SUITE(multi_span_tests)
|
||||
CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>()));
|
||||
CHECK((av.subspan<0, 5>().length() == 5));
|
||||
CHECK(av.subspan(0, 5).length() == 5);
|
||||
CHECK_THROW(av.subspan(0, 6).length(), fail_fast);
|
||||
CHECK_THROW(av.subspan(1, 5).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.subspan(0, 6).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.subspan(1, 5).length(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -824,7 +821,7 @@ SUITE(multi_span_tests)
|
||||
CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>()));
|
||||
CHECK((av.subspan<5, 0>().length() == 0));
|
||||
CHECK(av.subspan(5, 0).length() == 0);
|
||||
CHECK_THROW(av.subspan(6, 0).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.subspan(6, 0).length(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -832,13 +829,13 @@ SUITE(multi_span_tests)
|
||||
CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>()));
|
||||
CHECK((av.subspan<0, 0>().length() == 0));
|
||||
CHECK(av.subspan(0, 0).length() == 0);
|
||||
CHECK_THROW((av.subspan<1, 0>().length()), fail_fast);
|
||||
CHECK_THROWS_AS((av.subspan<1, 0>().length()), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
multi_span<int> av;
|
||||
CHECK(av.subspan(0).length() == 0);
|
||||
CHECK_THROW(av.subspan(1).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.subspan(1).length(), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -847,7 +844,7 @@ SUITE(multi_span_tests)
|
||||
CHECK(av.subspan(1).length() == 4);
|
||||
CHECK(av.subspan(4).length() == 1);
|
||||
CHECK(av.subspan(5).length() == 0);
|
||||
CHECK_THROW(av.subspan(6).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.subspan(6).length(), fail_fast);
|
||||
auto av2 = av.subspan(1);
|
||||
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
|
||||
}
|
||||
@ -858,13 +855,13 @@ SUITE(multi_span_tests)
|
||||
CHECK(av.subspan(1).length() == 4);
|
||||
CHECK(av.subspan(4).length() == 1);
|
||||
CHECK(av.subspan(5).length() == 0);
|
||||
CHECK_THROW(av.subspan(6).length(), fail_fast);
|
||||
CHECK_THROWS_AS(av.subspan(6).length(), fail_fast);
|
||||
auto av2 = av.subspan(1);
|
||||
for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(rank)
|
||||
TEST_CASE("rank")
|
||||
{
|
||||
int arr[2] = {1, 2};
|
||||
|
||||
@ -885,13 +882,13 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(extent)
|
||||
TEST_CASE("extent")
|
||||
{
|
||||
{
|
||||
multi_span<int> s;
|
||||
CHECK(s.extent() == 0);
|
||||
CHECK(s.extent(0) == 0);
|
||||
CHECK_THROW(s.extent(1), fail_fast);
|
||||
CHECK_THROWS_AS(s.extent(1), fail_fast);
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
CHECK(s.extent<1>() == 0);
|
||||
#endif
|
||||
@ -901,7 +898,7 @@ SUITE(multi_span_tests)
|
||||
multi_span<int, 0> s;
|
||||
CHECK(s.extent() == 0);
|
||||
CHECK(s.extent(0) == 0);
|
||||
CHECK_THROW(s.extent(1), fail_fast);
|
||||
CHECK_THROWS_AS(s.extent(1), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -913,7 +910,7 @@ SUITE(multi_span_tests)
|
||||
CHECK(s.extent<1>() == 2);
|
||||
CHECK(s.extent(0) == 1);
|
||||
CHECK(s.extent(1) == 2);
|
||||
CHECK_THROW(s.extent(3), fail_fast);
|
||||
CHECK_THROWS_AS(s.extent(3), fail_fast);
|
||||
}
|
||||
|
||||
{
|
||||
@ -925,18 +922,18 @@ SUITE(multi_span_tests)
|
||||
CHECK(s.extent<1>() == 2);
|
||||
CHECK(s.extent(0) == 0);
|
||||
CHECK(s.extent(1) == 2);
|
||||
CHECK_THROW(s.extent(3), fail_fast);
|
||||
CHECK_THROWS_AS(s.extent(3), fail_fast);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(operator_function_call)
|
||||
TEST_CASE("operator_function_call")
|
||||
{
|
||||
int arr[4] = {1, 2, 3, 4};
|
||||
|
||||
{
|
||||
multi_span<int> s = arr;
|
||||
CHECK(s(0) == 1);
|
||||
CHECK_THROW(s(5), fail_fast);
|
||||
CHECK_THROWS_AS(s(5), fail_fast);
|
||||
}
|
||||
|
||||
int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
|
||||
@ -957,7 +954,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(comparison_operators)
|
||||
TEST_CASE("comparison_operators")
|
||||
{
|
||||
{
|
||||
int arr[10][2];
|
||||
@ -967,7 +964,7 @@ SUITE(multi_span_tests)
|
||||
CHECK(s1 == s2);
|
||||
|
||||
multi_span<int, 20> s3 = as_multi_span(s1, dim(20));
|
||||
CHECK(s3 == s2 && s3 == s1);
|
||||
CHECK((s3 == s2 && s3 == s1));
|
||||
}
|
||||
|
||||
{
|
||||
@ -1069,7 +1066,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(basics)
|
||||
TEST_CASE("basics")
|
||||
{
|
||||
auto ptr = as_multi_span(new int[10], 10);
|
||||
fill(ptr.begin(), ptr.end(), 99);
|
||||
@ -1080,7 +1077,7 @@ SUITE(multi_span_tests)
|
||||
delete[] ptr.data();
|
||||
}
|
||||
|
||||
TEST(bounds_checks)
|
||||
TEST_CASE("bounds_checks")
|
||||
{
|
||||
int arr[10][2];
|
||||
auto av = as_multi_span(arr);
|
||||
@ -1091,17 +1088,17 @@ SUITE(multi_span_tests)
|
||||
av[1][1] = 3;
|
||||
|
||||
// out of bounds
|
||||
CHECK_THROW(av[1][3] = 3, fail_fast);
|
||||
CHECK_THROW((av[{1, 3}] = 3), fail_fast);
|
||||
CHECK_THROWS_AS(av[1][3] = 3, fail_fast);
|
||||
CHECK_THROWS_AS((av[{1, 3}] = 3), fail_fast);
|
||||
|
||||
CHECK_THROW(av[10][2], fail_fast);
|
||||
CHECK_THROW((av[{10, 2}]), fail_fast);
|
||||
CHECK_THROWS_AS(av[10][2], fail_fast);
|
||||
CHECK_THROWS_AS((av[{10, 2}]), fail_fast);
|
||||
|
||||
CHECK_THROW(av[-1][0], fail_fast);
|
||||
CHECK_THROW((av[{-1, 0}]), fail_fast);
|
||||
CHECK_THROWS_AS(av[-1][0], fail_fast);
|
||||
CHECK_THROWS_AS((av[{-1, 0}]), fail_fast);
|
||||
|
||||
CHECK_THROW(av[0][-1], fail_fast);
|
||||
CHECK_THROW((av[{0, -1}]), fail_fast);
|
||||
CHECK_THROWS_AS(av[0][-1], fail_fast);
|
||||
CHECK_THROWS_AS((av[{0, -1}]), fail_fast);
|
||||
}
|
||||
|
||||
void overloaded_func(multi_span<const int, dynamic_range, 3, 5> exp, int expected_value)
|
||||
@ -1125,7 +1122,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(span_parameter_test)
|
||||
TEST_CASE("span_parameter_test")
|
||||
{
|
||||
auto data = new int[4][3][5];
|
||||
|
||||
@ -1146,7 +1143,7 @@ SUITE(multi_span_tests)
|
||||
delete[] data;
|
||||
}
|
||||
|
||||
TEST(md_access)
|
||||
TEST_CASE("md_access")
|
||||
{
|
||||
auto width = 5, height = 20;
|
||||
|
||||
@ -1178,7 +1175,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(as_multi_span)
|
||||
TEST_CASE("as_multi_span")
|
||||
{
|
||||
{
|
||||
int* arr = new int[150];
|
||||
@ -1233,15 +1230,15 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(empty_spans)
|
||||
TEST_CASE("empty_spans")
|
||||
{
|
||||
{
|
||||
multi_span<int, 0> empty_av(nullptr);
|
||||
|
||||
CHECK(empty_av.bounds().index_bounds() == index<1>{0});
|
||||
CHECK_THROW(empty_av[0], fail_fast);
|
||||
CHECK_THROW(empty_av.begin()[0], fail_fast);
|
||||
CHECK_THROW(empty_av.cbegin()[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_av[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_av.begin()[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast);
|
||||
for (auto& v : empty_av) {
|
||||
(void) v;
|
||||
CHECK(false);
|
||||
@ -1251,9 +1248,9 @@ SUITE(multi_span_tests)
|
||||
{
|
||||
multi_span<int> empty_av = {};
|
||||
CHECK(empty_av.bounds().index_bounds() == index<1>{0});
|
||||
CHECK_THROW(empty_av[0], fail_fast);
|
||||
CHECK_THROW(empty_av.begin()[0], fail_fast);
|
||||
CHECK_THROW(empty_av.cbegin()[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_av[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_av.begin()[0], fail_fast);
|
||||
CHECK_THROWS_AS(empty_av.cbegin()[0], fail_fast);
|
||||
for (auto& v : empty_av) {
|
||||
(void) v;
|
||||
CHECK(false);
|
||||
@ -1261,7 +1258,7 @@ SUITE(multi_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(index_constructor)
|
||||
TEST_CASE("index_constructor")
|
||||
{
|
||||
auto arr = new int[8];
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
@ -1286,7 +1283,10 @@ SUITE(multi_span_tests)
|
||||
delete[] arr;
|
||||
}
|
||||
|
||||
TEST(index_constructors){{// components of the same type
|
||||
TEST_CASE("index_constructors")
|
||||
{
|
||||
{
|
||||
// components of the same type
|
||||
index<3> i1(0, 1, 2);
|
||||
CHECK(i1[0] == 0);
|
||||
|
||||
@ -1355,7 +1355,7 @@ SUITE(multi_span_tests)
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(index_operations)
|
||||
TEST_CASE("index_operations")
|
||||
{
|
||||
ptrdiff_t a[3] = {0, 1, 2};
|
||||
ptrdiff_t b[3] = {3, 4, 5};
|
||||
@ -1465,7 +1465,7 @@ void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(span_section_iteration)
|
||||
TEST_CASE("span_section_iteration")
|
||||
{
|
||||
int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}};
|
||||
|
||||
@ -1491,7 +1491,7 @@ TEST(span_section_iteration)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(dynamic_span_section_iteration)
|
||||
TEST_CASE("dynamic_span_section_iteration")
|
||||
{
|
||||
auto height = 4, width = 2;
|
||||
auto size = height * width;
|
||||
@ -1523,7 +1523,7 @@ TEST(dynamic_span_section_iteration)
|
||||
delete[] arr;
|
||||
}
|
||||
|
||||
TEST(span_structure_size)
|
||||
TEST_CASE("span_structure_size")
|
||||
{
|
||||
double(*arr)[3][4] = new double[100][3][4];
|
||||
multi_span<double, dynamic_range, 3, 4> av1(arr, 10);
|
||||
@ -1535,14 +1535,14 @@ TEST(span_structure_size)
|
||||
};
|
||||
CHECK(sizeof(av1) == sizeof(EffectiveStructure));
|
||||
|
||||
CHECK_THROW(av1[10][3][4], fail_fast);
|
||||
CHECK_THROWS_AS(av1[10][3][4], fail_fast);
|
||||
|
||||
multi_span<const double, dynamic_range, 6, 4> av2 =
|
||||
as_multi_span(av1, dim(5), dim<6>(), dim<4>());
|
||||
(void) av2;
|
||||
}
|
||||
|
||||
TEST(fixed_size_conversions)
|
||||
TEST_CASE("fixed_size_conversions")
|
||||
{
|
||||
int arr[] = {1, 2, 3, 4};
|
||||
|
||||
@ -1626,7 +1626,7 @@ TEST(fixed_size_conversions)
|
||||
multi_span<int, 4> av9 = {arr2, 2};
|
||||
(void) av9;
|
||||
};
|
||||
CHECK_THROW(f(), fail_fast);
|
||||
CHECK_THROWS_AS(f(), fail_fast);
|
||||
}
|
||||
|
||||
// this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one
|
||||
@ -1635,10 +1635,10 @@ TEST(fixed_size_conversions)
|
||||
multi_span<int, 4> av2 = av;
|
||||
(void) av2;
|
||||
};
|
||||
CHECK_THROW(f(), fail_fast);
|
||||
CHECK_THROWS_AS(f(), fail_fast);
|
||||
}
|
||||
|
||||
TEST(as_writeable_bytes)
|
||||
TEST_CASE("as_writeable_bytes")
|
||||
{
|
||||
int a[] = {1, 2, 3, 4};
|
||||
|
||||
@ -1666,7 +1666,7 @@ TEST(as_writeable_bytes)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(iterator)
|
||||
TEST_CASE("iterator")
|
||||
{
|
||||
int a[] = {1, 2, 3, 4};
|
||||
|
||||
@ -1691,6 +1691,3 @@ TEST(iterator)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(int, const char* []) { return UnitTest::RunAllTests(); }
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/gsl>
|
||||
|
||||
@ -104,13 +104,9 @@ struct NonCopyableNonMovable
|
||||
NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
|
||||
};
|
||||
|
||||
|
||||
SUITE(NotNullTests)
|
||||
{
|
||||
|
||||
bool helper(not_null<int*> p) { return *p == 12; }
|
||||
|
||||
TEST(TestNotNullConstructors)
|
||||
TEST_CASE("TestNotNullConstructors")
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
not_null<int*> p = nullptr; // yay...does not compile!
|
||||
@ -133,7 +129,7 @@ SUITE(NotNullTests)
|
||||
std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
|
||||
}
|
||||
|
||||
TEST(TestNotNullCasting)
|
||||
TEST_CASE("TestNotNullCasting")
|
||||
{
|
||||
MyBase base;
|
||||
MyDerived derived;
|
||||
@ -156,17 +152,17 @@ SUITE(NotNullTests)
|
||||
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];
|
||||
@ -193,12 +189,39 @@ 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(TestNotNullSharedPtrComparison)
|
||||
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));
|
||||
}
|
||||
|
||||
{
|
||||
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);
|
||||
@ -229,7 +252,7 @@ SUITE(NotNullTests)
|
||||
CHECK((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
|
||||
}
|
||||
|
||||
TEST(TestNotNullCustomPtrComparison)
|
||||
TEST_CASE("TestNotNullCustomPtrComparison")
|
||||
{
|
||||
int ints[2] = {42, 43};
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
@ -260,36 +283,3 @@ SUITE(NotNullTests)
|
||||
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,11 +24,9 @@
|
||||
|
||||
using namespace gsl;
|
||||
|
||||
SUITE(owner_tests)
|
||||
{
|
||||
void f(int* i) { *i += 1; }
|
||||
|
||||
TEST(basic_test)
|
||||
TEST_CASE("basic_test")
|
||||
{
|
||||
owner<int*> p = new int(120);
|
||||
CHECK(*p == 120);
|
||||
@ -37,7 +35,7 @@ SUITE(owner_tests)
|
||||
delete p;
|
||||
}
|
||||
|
||||
TEST(check_pointer_constraint)
|
||||
TEST_CASE("check_pointer_constraint")
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
{
|
||||
@ -46,6 +44,3 @@ SUITE(owner_tests)
|
||||
}
|
||||
#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,9 +38,7 @@ struct DerivedClass : BaseClass
|
||||
};
|
||||
}
|
||||
|
||||
SUITE(strided_span_tests)
|
||||
{
|
||||
TEST(span_section_test)
|
||||
TEST_CASE("span_section_test")
|
||||
{
|
||||
int a[30][4][5];
|
||||
|
||||
@ -50,7 +48,7 @@ SUITE(strided_span_tests)
|
||||
(void) subsub;
|
||||
}
|
||||
|
||||
TEST(span_section)
|
||||
TEST_CASE("span_section")
|
||||
{
|
||||
std::vector<int> data(5 * 10);
|
||||
std::iota(begin(data), end(data), 0);
|
||||
@ -68,7 +66,7 @@ SUITE(strided_span_tests)
|
||||
CHECK((av_section_2[{1, 0}] == 34));
|
||||
}
|
||||
|
||||
TEST(strided_span_constructors)
|
||||
TEST_CASE("strided_span_constructors")
|
||||
{
|
||||
// Check stride constructor
|
||||
{
|
||||
@ -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}));
|
||||
@ -268,7 +266,7 @@ SUITE(strided_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(strided_span_slice)
|
||||
TEST_CASE("strided_span_slice")
|
||||
{
|
||||
std::vector<int> data(5 * 10);
|
||||
std::iota(begin(data), end(data), 0);
|
||||
@ -294,7 +292,7 @@ SUITE(strided_span_tests)
|
||||
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
|
||||
@ -326,7 +324,7 @@ SUITE(strided_span_tests)
|
||||
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);
|
||||
@ -334,15 +332,15 @@ SUITE(strided_span_tests)
|
||||
{
|
||||
// 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
|
||||
@ -442,7 +440,7 @@ SUITE(strided_span_tests)
|
||||
#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,9 +558,9 @@ 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;
|
||||
@ -596,7 +594,7 @@ SUITE(strided_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(strided_span_section_iteration)
|
||||
TEST_CASE("strided_span_section_iteration")
|
||||
{
|
||||
int arr[8] = {4, 0, 5, 1, 6, 2, 7, 3};
|
||||
|
||||
@ -613,7 +611,7 @@ SUITE(strided_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
@ -653,7 +651,7 @@ SUITE(strided_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
@ -667,7 +665,7 @@ SUITE(strided_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
@ -699,7 +697,7 @@ SUITE(strided_span_tests)
|
||||
delete[] arr;
|
||||
}
|
||||
|
||||
TEST(strided_span_conversion)
|
||||
TEST_CASE("strided_span_conversion")
|
||||
{
|
||||
// get an multi_span of 'c' values from the list of X's
|
||||
|
||||
@ -744,7 +742,7 @@ 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) {
|
||||
@ -752,6 +750,3 @@ SUITE(strided_span_tests)
|
||||
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,10 +26,7 @@
|
||||
using namespace std;
|
||||
using namespace gsl;
|
||||
|
||||
SUITE(string_span_tests)
|
||||
{
|
||||
|
||||
TEST(TestLiteralConstruction)
|
||||
TEST_CASE("TestLiteralConstruction")
|
||||
{
|
||||
cwstring_span<> v = ensure_z(L"Hello");
|
||||
CHECK(5 == v.length());
|
||||
@ -39,21 +36,21 @@ SUITE(string_span_tests)
|
||||
#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";
|
||||
|
||||
@ -78,14 +75,14 @@ SUITE(string_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
@ -93,7 +90,7 @@ SUITE(string_span_tests)
|
||||
CHECK(v.length() == v2.length());
|
||||
}
|
||||
|
||||
TEST(TestConversionFromConst)
|
||||
TEST_CASE("TestConversionFromConst")
|
||||
{
|
||||
char stack_string[] = "Hello";
|
||||
cstring_span<> v = ensure_z(stack_string);
|
||||
@ -104,7 +101,7 @@ SUITE(string_span_tests)
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(TestToString)
|
||||
TEST_CASE("TestToString")
|
||||
{
|
||||
auto s = gsl::to_string(cstring_span<>{});
|
||||
CHECK(s.length() == 0);
|
||||
@ -116,7 +113,7 @@ SUITE(string_span_tests)
|
||||
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<>{});
|
||||
@ -129,7 +126,7 @@ SUITE(string_span_tests)
|
||||
CHECK(s2.length() == 5);
|
||||
}
|
||||
|
||||
TEST(EqualityAndImplicitConstructors)
|
||||
TEST_CASE("EqualityAndImplicitConstructors")
|
||||
{
|
||||
{
|
||||
cstring_span<> span = "Hello";
|
||||
@ -355,7 +352,7 @@ SUITE(string_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ComparisonAndImplicitConstructors)
|
||||
TEST_CASE("ComparisonAndImplicitConstructors")
|
||||
{
|
||||
{
|
||||
cstring_span<> span = "Hello";
|
||||
@ -425,7 +422,7 @@ SUITE(string_span_tests)
|
||||
CHECK(span >= string_span<>(vec));
|
||||
}
|
||||
}
|
||||
TEST(ConstrutorsEnsureZ)
|
||||
TEST_CASE("ConstrutorsEnsureZ")
|
||||
{
|
||||
// remove z from literals
|
||||
{
|
||||
@ -455,7 +452,7 @@ SUITE(string_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Constructors)
|
||||
TEST_CASE("Constructors")
|
||||
{
|
||||
// creating cstring_span
|
||||
|
||||
@ -767,7 +764,7 @@ SUITE(string_span_tests)
|
||||
{
|
||||
}
|
||||
|
||||
TEST(MoveConstructors)
|
||||
TEST_CASE("MoveConstructors")
|
||||
{
|
||||
// move string_span
|
||||
{
|
||||
@ -841,7 +838,7 @@ SUITE(string_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Conversion)
|
||||
TEST_CASE("Conversion")
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
cstring_span<> span = "Hello";
|
||||
@ -867,7 +864,7 @@ SUITE(string_span_tests)
|
||||
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
|
||||
@ -921,7 +918,7 @@ SUITE(string_span_tests)
|
||||
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
|
||||
@ -958,12 +955,9 @@ SUITE(string_span_tests)
|
||||
}
|
||||
}
|
||||
|
||||
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,11 +22,9 @@
|
||||
|
||||
using namespace gsl;
|
||||
|
||||
SUITE(utils_tests)
|
||||
{
|
||||
void f(int& i) { i += 1; }
|
||||
|
||||
TEST(finally_lambda)
|
||||
TEST_CASE("finally_lambda")
|
||||
{
|
||||
int i = 0;
|
||||
{
|
||||
@ -36,7 +34,7 @@ SUITE(utils_tests)
|
||||
CHECK(i == 1);
|
||||
}
|
||||
|
||||
TEST(finally_lambda_move)
|
||||
TEST_CASE("finally_lambda_move")
|
||||
{
|
||||
int i = 0;
|
||||
{
|
||||
@ -55,7 +53,7 @@ SUITE(utils_tests)
|
||||
CHECK(i == 1);
|
||||
}
|
||||
|
||||
TEST(finally_function_with_bind)
|
||||
TEST_CASE("finally_function_with_bind")
|
||||
{
|
||||
int i = 0;
|
||||
{
|
||||
@ -67,7 +65,7 @@ SUITE(utils_tests)
|
||||
|
||||
int j = 0;
|
||||
void g() { j += 1; }
|
||||
TEST(finally_function_ptr)
|
||||
TEST_CASE("finally_function_ptr")
|
||||
{
|
||||
j = 0;
|
||||
{
|
||||
@ -77,7 +75,7 @@ SUITE(utils_tests)
|
||||
CHECK(j == 1);
|
||||
}
|
||||
|
||||
TEST(narrow_cast)
|
||||
TEST_CASE("narrow_cast")
|
||||
{
|
||||
int n = 120;
|
||||
char c = narrow_cast<char>(n);
|
||||
@ -88,14 +86,14 @@ SUITE(utils_tests)
|
||||
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