Merge pull request #870 from beinhaerter/suppress_span_warning

suppress code analysis warning

.travis.yml

@@ -1,246 +1,519 @@
-# Based on https://github.com/ldionne/hana/blob/master/.travis.yml
 
 language: cpp
-sudo: false
 notifications:
   email: false
 
 # Use Linux unless specified otherwise
 os: linux
-dist: trusty
+dist: bionic
 
 cache:
   directories:
     - ${TRAVIS_BUILD_DIR}/deps
 
-matrix:
+stages:
+  - name: Latest     # build jobs to run first and always
+  - name: Validation # run other jobs
+  - name: Legacy     # build with all other supported compilers
+
+jobs:
   include:
 
     ##########################################################################
-    # Clang on OSX
-    # Travis seems to take longer to start OSX instances,
-    # so leave this first for the overall build to be faster
+    # Validate CMake configuration
     ##########################################################################
 
-    # XCode 8.3
-    - env: COMPILER=clang++ BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: CMake 3.1.3 - latest
+      stage: Validation
+      env: &CMAKE_VERSION_LIST
+      - CMAKE_VERSION: '"3.17.0 3.16.5 3.15.7 3.14.7 3.13.5 3.12.4 3.11.4 3.10.3 3.9.6 3.8.2 3.7.2 3.6.3 3.5.2 3.4.3 3.3.2 3.2.3 3.1.3"'
+      - GSL_CXX_STANDARD: 14
+      addons: # Get latest release (candidate)
+        apt:
+          sources:
+          - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
+            key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
+          - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic-rc main'
+          packages:
+          - cmake
+      script:
+      - |
+        cd ./build
+        ( set -eu
+          for CMAKE in ${CMAKE_path[@]}; do test_CMake_generate $CMAKE; done
+          export CXX=clang++
+          for CMAKE in ${CMAKE_path[@]}; do test_CMake_generate $CMAKE; done
+        )
+
+    - name: CMake 3.2.3 - 3.17.0
+      stage: Validation
+      os: osx
+      osx_image: xcode11.3
+      env:
+      - CMAKE_VERSION: '"3.17.0 3.16.5 3.15.7 3.14.7 3.13.5 3.12.4 3.11.4 3.10.3 3.9.6 3.8.2 3.7.2 3.6.3 3.5.2 3.4.3 3.3.2 3.2.3"'
+      script:
+      - |
+        cd ./build
+        ( set -eu
+          for CMAKE in ${CMAKE_path[@]}; do test_CMake_generate $CMAKE; done
+        )
+
+    ##########################################################################
+    # AppleClang on OSX
+    ##########################################################################
+
+    # Xcode 8.3
+    - name: AppleClang Xcode-8.3 C++14 Debug
+      stage: Legacy
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       os: osx
       osx_image: xcode8.3
-      compiler: clang
-
-    - env: COMPILER=clang++ BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: AppleClang Xcode-8.3 C++14 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
       os: osx
       osx_image: xcode8.3
-      compiler: clang
 
-    # XCode 9.1
-    - env: COMPILER=clang++ BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    # Xcode 9.0 earliest C++17 support
+    - name: AppleClang Xcode-9.0 C++17 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
       os: osx
-      osx_image: xcode9.1
-      compiler: clang
+      osx_image: xcode9 # AppleClang 9.1.0 same compiler in Xcode 9.0, 9.1 and 9.2
+    - name: AppleClang Xcode-9.0 C++17 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode9
+    - name: AppleClang Xcode-9.0 C++14 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode9
+    - name: AppleClang Xcode-9.0 C++14 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode9
 
-    - env: COMPILER=clang++ BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    # Xcode 9.4
+    - name: AppleClang Xcode-9.4 C++14 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       os: osx
-      osx_image: xcode9.1
-      compiler: clang
+      osx_image: xcode9.4 # AppleClang 9.1.0 same compiler as Xcode 9.3
+    - name: AppleClang Xcode-9.4 C++14 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode9.4
+    - name: AppleClang Xcode-9.4 C++17 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode9.4
+    - name: AppleClang Xcode-9.4 C++17 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode9.4
+
+    # Xcode 10.1
+    - name: AppleClang Xcode-10.1 C++14 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode10.1 # AppleClang 10.0.0 same compiler as Xcode 10.0
+    - name: AppleClang Xcode-10.1 C++14 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode10.1
+    - name: AppleClang Xcode-10.1 C++17 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode10.1
+    - name: AppleClang Xcode-10.1 C++17 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode10.1
+
+    # Xcode 10.3
+    - name: AppleClang Xcode-10.3 C++14 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode10.3 # AppleClang 10.0.1 same compiler as Xcode 10.2
+    - name: AppleClang Xcode-10.3 C++14 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode10.3
+    - name: AppleClang Xcode-10.3 C++17 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode10.3
+    - name: AppleClang Xcode-10.3 C++17 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode10.3
+
+    # Xcode 11.3
+    - name: AppleClang Xcode-11.3 C++17 Debug
+      stage: Latest
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode11.3 # AppleClang 11.0.0 linker update / same as Xcode 11.2
+    - name: AppleClang Xcode-11.3 C++17 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      os: osx
+      osx_image: xcode11.3
+    - name: AppleClang Xcode-11.3 C++14 Debug
+      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode11.3
+    - name: AppleClang Xcode-11.3 C++14 Release
+      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      os: osx
+      osx_image: xcode11.3
 
     ##########################################################################
     # Clang on Linux
     ##########################################################################
 
     # Clang 3.6
-    - env: COMPILER=clang++-3.6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-3.6 C++14 Debug
+      stage: Legacy
+      dist: xenial
+      env: CXX=clang++-3.6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang36
         apt:
           packages:
             - clang-3.6
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - env: COMPILER=clang++-3.6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-3.6 C++14 Release
+      dist: xenial
+      env: CXX=clang++-3.6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *clang36
 
     # Clang 3.7
-    - env: COMPILER=clang++-3.7 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-3.7 C++14 Debug
+      dist: xenial
+      env: CXX=clang++-3.7 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang37
         apt:
           packages:
             - clang-3.7
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - env: COMPILER=clang++-3.7 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-3.7 C++14 Release
+      dist: xenial
+      env: CXX=clang++-3.7 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *clang37
 
     # Clang 3.8
-    - env: COMPILER=clang++-3.8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-3.8 C++14 Debug
+      dist: xenial
+      env: CXX=clang++-3.8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang38
         apt:
           packages:
             - clang-3.8
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - env: COMPILER=clang++-3.8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-3.8 C++14 Release
+      dist: xenial
+      env: CXX=clang++-3.8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *clang38
 
     # Clang 3.9
-    - env: COMPILER=clang++-3.9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-3.9 C++14 Debug
+      env: CXX=clang++-3.9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang39
         apt:
           packages:
             - clang-3.9
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
-
-    - env: COMPILER=clang++-3.9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-3.9 C++14 Release
+      env: CXX=clang++-3.9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *clang39
 
     # Clang 4.0
-    - env: COMPILER=clang++-4.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-4.0 C++14 Debug
+      env: CXX=clang++-4.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang40
         apt:
           packages:
             - clang-4.0
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - env: COMPILER=clang++-4.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-4.0 C++14 Release
+      env: CXX=clang++-4.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *clang40
 
     # Clang 5.0
-    - env: COMPILER=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-5.0 C++14 Debug
+      env: CXX=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang50
         apt:
           packages:
             - clang-5.0
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - env: COMPILER=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-5.0 C++14 Release
+      env: CXX=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *clang50
-
-    - env: COMPILER=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+    - name: Clang-5.0 C++17 Debug
+      env: CXX=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
       addons: *clang50
-
-    - env: COMPILER=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+    - name: Clang 5.0 C++17 Release
+      env: CXX=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
       addons: *clang50
 
     # Clang 6.0
-    - env: COMPILER=clang++-6.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-6.0 C++14 Debug
+      env: CXX=clang++-6.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &clang60
         apt:
           packages:
             - clang-6.0
-            - g++-7
+    - name: Clang 6.0 C++14 Release
+      env: CXX=clang++-6.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      addons: *clang60
+    - name: Clang-6.0 C++17 Debug
+      env: CXX=clang++-6.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      addons: *clang60
+    - name: Clang 6.0 C++17 Release
+      env: CXX=clang++-6.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      addons: *clang60
+
+    # Clang 7 (default on Xenial and Bionic images)
+    - name: Clang-7 C++14 Debug
+      env: CXX=clang++ BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: Clang-7 C++14 Release
+      env: CXX=clang++ BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: Clang-7 C++17 Debug
+      env: CXX=clang++ BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+    - name: Clang-7 C++17 Release
+      env: CXX=clang++ BUILD_TYPE=Release GSL_CXX_STANDARD=17
+
+    # Clang 8
+    - name: Clang-8 C++14 Debug
+      env: CXX=clang++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      addons: &clang8
+        apt:
           sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+          - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main'
+            key_url: https://apt.llvm.org/llvm-snapshot.gpg.key
+          packages:
+          - clang-8
+    - name: Clang-8 C++14 Release
+      env: CXX=clang++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      addons: *clang8
+    - name: Clang-8 C++17 Debug
+      env: CXX=clang++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      addons: *clang8
+    - name: Clang-8 C++17 Release
+      env: CXX=clang++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      addons: *clang8
 
-    - env: COMPILER=clang++-6.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *clang60
+    # Clang 9
+    - name: Clang-9 C++14 Debug
+      env: CXX=clang++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      addons: &clang9
+        apt:
+          sources:
+          - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
+            key_url: https://apt.llvm.org/llvm-snapshot.gpg.key
+          packages:
+          - clang-9
+    - name: Clang-9 C++14 Release
+      env: CXX=clang++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      addons: *clang9
+    - name: Clang-9 C++17 Debug
+      env: CXX=clang++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      addons: *clang9
+    - name: Clang-9 C++17 Release
+      env: CXX=clang++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      addons: *clang9
 
-    # Clang 6.0 c++17
-    - env: COMPILER=clang++-6.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
-      addons: *clang60
-
-    - env: COMPILER=clang++-6.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
-      addons: *clang60
+    # Clang 10
+    - name: Clang-10 C++14 Debug
+      stage: Latest
+      env: CXX=clang++-10 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      addons: &clang10
+        apt:
+          sources:
+          - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+            key_url: https://apt.llvm.org/llvm-snapshot.gpg.key
+          packages:
+          - clang-10
+    - name: Clang-10 C++14 Release
+      env: CXX=clang++-10 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      addons: *clang10
+    - name: Clang-10 C++17 Debug
+      env: CXX=clang++-10 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      addons: *clang10
+    - name: Clang-10 C++17 Release
+      env: CXX=clang++-10 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      addons: *clang10
 
     ##########################################################################
     # GCC on Linux
     ##########################################################################
 
-    # GCC 5
-    - env: COMPILER=g++-5 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
-      addons: &gcc5
-        apt:
-          packages: g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - env: COMPILER=g++-5 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *gcc5
+    # GCC 5 (default on the Xenial image)
+    - name: GCC-5 C++14 Debug
+      stage: Legacy
+      dist: xenial
+      env: CXX=g++-5 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: GCC-5 C++14 Release
+      dist: xenial
+      env: CXX=g++-5 BUILD_TYPE=Release GSL_CXX_STANDARD=14
 
     # GCC 6
-    - env: COMPILER=g++-6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: GCC-6 C++14 Debug
+      env: CXX=g++-6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
       addons: &gcc6
         apt:
           packages: g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - env: COMPILER=g++-6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: GCC-6 C++14 Release
+      env: CXX=g++-6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
       addons: *gcc6
 
-    # GCC 7
-    - env: COMPILER=g++-7 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
-      addons: &gcc7
+    # GCC 7 (default on the Bionic image)
+    - name: GCC-7 C++14 Debug
+      env: CXX=g++-7 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+    - name: GCC-7 C++14 Release
+      env: CXX=g++-7 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+    - name: GCC-7 C++17 Debug
+      env: CXX=g++-7 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+    - name: GCC-7 C++17 Release
+      env: CXX=g++-7 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+
+    # GCC 8
+    - name: GCC-8 C++14 Debug
+      env: CXX=g++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      addons: &gcc8
+        apt:
+          packages: g++-8
+    - name: GCC-8 C++14 Release
+      env: CXX=g++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      addons: *gcc8
+    - name: GCC-8 C++17 Debug
+      env: CXX=g++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      addons: *gcc8
+    - name: GCC-8 C++17 Release
+      env: CXX=g++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      addons: *gcc8
+
+    # GCC 9
+    - name: GCC-9 C++14 Debug
+      stage: Latest
+      env: CXX=g++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
+      addons: &gcc9
         apt:
-          packages: g++-7
           sources:
-            - ubuntu-toolchain-r-test
+          - sourceline: ppa:ubuntu-toolchain-r/test
+          packages:
+          - g++-9
+    - name: GCC-9 C++14 Release
+      env: CXX=g++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
+      addons: *gcc9
+    - name: GCC-9 C++17 Debug
+      env: CXX=g++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
+      addons: *gcc9
+    - name: GCC-9 C++17 Release
+      env: CXX=g++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=17
+      addons: *gcc9
 
-    - env: COMPILER=g++-7 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *gcc7
-
-    # GCC 7 c++17 
-    - env: COMPILER=g++-7 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
-      addons: *gcc7
-
-    - env: COMPILER=g++-7 BUILD_TYPE=Release GSL_CXX_STANDARD=17
-      addons: *gcc7
+before_install:
+  - |
+    # Configuration
+    JOBS=2 # Travis machines have 2 cores
+    # Dependencies required by the CI (cached directory)
+    DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
+  - |
+    # Setup
+    mkdir -p "${DEPS_DIR:?}" && cd "${DEPS_DIR:?}"
+    mkdir -p ~/tools && cd ~/tools
+    if [[ ${TRAVIS_OS_NAME:?} == "osx" ]]; then
+      export PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH"
+    fi
+  - |
+    # Helper functions
+    # usage: if [[ $(check_url '<url>') ]]; then ...
+    function check_url {( set +e
+      if [[ "$1" =~ 'github.com' ]]; then # check for first byte
+        if curl --fail --silent --output /dev/null --connect-timeout 12 --range 0-0 "$1"
+        then echo true; fi
+      else # request head
+        if curl --fail --silent --output /dev/null --connect-timeout 12 --head "$1"
+        then echo true; fi
+      fi
+      return
+    )}
 
 install:
-  # Set the ${CXX} variable properly
-  - export CXX=${COMPILER}
-  - ${CXX} --version
-
-  # Dependencies required by the CI are installed in ${TRAVIS_BUILD_DIR}/deps/
-  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
-  - mkdir -p "${DEPS_DIR}"
-  - cd "${DEPS_DIR}"
-
-  # Travis machines have 2 cores
-  - JOBS=2
-
   ############################################################################
-  # Install a recent CMake (unless already installed on OS X)
+  # Install a different CMake version (or several)
   ############################################################################
-  - CMAKE_VERSION=3.7.2
   - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      CMAKE_URL="https://cmake.org/files/v${CMAKE_VERSION%.[0-9]}/cmake-${CMAKE_VERSION}-Linux-x86_64.tar.gz"
-      mkdir cmake && travis_retry wget --no-check-certificate -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
-      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
-    else
-      brew install cmake || brew upgrade cmake
+    # Install CMake versions
+    ( set -euo pipefail
+      if [[ ${CMAKE_VERSION:-} ]]; then
+        if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+          OS="Linux"; EXT="sh"
+          if [[ ! ("${CMAKE_VERSION:-}" =~ .+[' '].+) ]]; then
+            # Single entry -> default CMake version
+            CMAKE_DEFAULT_DIR="/usr/local"
+          fi
+        elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then OS="Darwin"; EXT="tar.gz"
+        else echo "CMake install not supported for this OS."; exit 1
+        fi
+        CMAKE_INSTALLER="install-cmake.${EXT}"
+      fi
+      for VERSION in ${CMAKE_VERSION:-}; do
+        CMAKE_URL="https://github.com/Kitware/CMake/releases/download/v${VERSION}/cmake-${VERSION}-${OS}-x86_64.${EXT}"
+        if [[ $(check_url "$CMAKE_URL") ]]; then
+          curl -sSL ${CMAKE_URL} -o ${CMAKE_INSTALLER}
+          CMAKE_DIR="${CMAKE_DEFAULT_DIR:-"${HOME}/tools/cmake-${VERSION}"}"
+          mkdir -p ${CMAKE_DIR}
+          if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+            chmod +x ${CMAKE_INSTALLER}
+            sudo ./${CMAKE_INSTALLER} --prefix=${CMAKE_DIR} --skip-license
+          else # OSX
+            mkdir -p ./CMake_tmp
+            tar --extract --gzip --file=${CMAKE_INSTALLER} --directory=./CMake_tmp
+            mv ./CMake_tmp/*/CMake.app/Contents/* ${CMAKE_DIR}
+          fi
+          rm --recursive --force ./CMake_tmp ${CMAKE_INSTALLER}
+        else echo 'Invalid url!'; echo "Version: ${VERSION}"
+        fi
+      done
+    )
+    if [[ ${CMAKE_VERSION:-} && "${TRAVIS_OS_NAME:?}" == "osx" && ! ("${CMAKE_VERSION:-}" =~ .+[' '].+) ]]
+    then # Single entry -> default CMake version
+      export PATH=${HOME}/tools/cmake-${CMAKE_VERSION:?}/bin:$PATH
+    fi
+    CMAKE_path=("cmake") # start with installed CMake version
+    for VERSION in ${CMAKE_VERSION:-}; do
+      tmp_path="$HOME/tools/cmake-${VERSION:?}/bin/cmake"
+      if [[ -x "$(command -v ${tmp_path:?})" ]]; then CMAKE_path+=("${tmp_path:?}"); fi
+    done
+    function test_CMake_generate {
+      # $1: cmake or full path to cmake
+      shopt -s extglob
+      if [[ "$1" == "cmake" || -x "$(command -v $1)" && "$1" =~ .*cmake$ ]]; then
+        echo "----------------"
+        $1 --version
+        echo "Configuration = ${BUILD_TYPE:-Debug}"
+        $1 -DCMAKE_BUILD_TYPE=${BUILD_TYPE:-Debug} ${CMAKE_GEN_FLAGS[@]:?} ..
+        rm -rf !(tests/googletest-*)
+        if [[ ! ${BUILD_TYPE:-} ]]; then echo "" && echo "Configuration = Release"
+          $1 -DCMAKE_BUILD_TYPE=Release ${CMAKE_GEN_FLAGS[@]:?} ..
+          rm -rf !(tests/googletest-*)
+        fi
+      else echo "Non existing command: $1"
+      fi
+    }
+  - |
+    # CMake wrapper (Trusty, Xenial & Bionic); restore default behaviour.
+    if [[ "${TRAVIS_OS_NAME:?}" == "linux" &&
+          "$(lsb_release --codename)" =~ (trusty|xenial|bionic)$ ]]
+    then
+      if [[ -x $(command -v /usr/local/bin/cmake) ]]; then
+        function cmake { command /usr/local/bin/cmake $@; }
+      elif [[ -x $(command -v /usr/bin/cmake) ]]; then
+        function cmake { command /usr/bin/cmake $@; }
+      fi
     fi
-  - cmake --version
 
   ############################################################################
   # [linux]: Install the right version of libc++
+  # Based on https://github.com/ldionne/hana/blob/master/.travis.yml
   ############################################################################
   - |
-    LLVM_INSTALL=${DEPS_DIR}/llvm/install
+    LLVM_INSTALL=${DEPS_DIR:?}/llvm/install
     # if in linux and compiler clang and llvm not installed
-    if [[ "${TRAVIS_OS_NAME}" == "linux" && "${CXX%%+*}" == "clang" && -n "$(ls -A ${LLVM_INSTALL})" ]]; then
+    if [[ "${TRAVIS_OS_NAME:?}" == "linux" && "${CXX%%+*}" == "clang" && -n "$(ls -A ${LLVM_INSTALL:?})" ]]; then
       if   [[ "${CXX}" == "clang++-3.6" ]]; then LLVM_VERSION="3.6.2";
       elif [[ "${CXX}" == "clang++-3.7" ]]; then LLVM_VERSION="3.7.1";
       elif [[ "${CXX}" == "clang++-3.8" ]]; then LLVM_VERSION="3.8.1";
@@ -262,12 +535,17 @@ install:
     fi
 
 before_script:
-  # have CMake to generate build files
-  - cd "${TRAVIS_BUILD_DIR}"
-  - mkdir build && cd build
-  - cmake .. -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DGSL_CXX_STANDARD=$GSL_CXX_STANDARD
-  
+  - |
+    cd "${TRAVIS_BUILD_DIR:?}"
+    mkdir build && cd build
+    if [[ ${GSL_CXX_STANDARD:-} ]]; then 
+      CMAKE_GEN_FLAGS=("-DGSL_CXX_STANDARD=$GSL_CXX_STANDARD")
+    fi
+    CMAKE_GEN_FLAGS+=("-Wdev -Werror=dev --warn-uninitialized")
+
 script:
+  # generate build files
+  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE:?} ${CMAKE_GEN_FLAGS[@]:?}
   # build and run tests
   - cmake --build . -- -j${JOBS}
   - ctest --output-on-failure -j${JOBS}

CMakeLists.txt

@@ -1,10 +1,13 @@
-cmake_minimum_required(VERSION 3.1.3)
+cmake_minimum_required(VERSION 3.1.3...3.16)
 
 project(GSL CXX)
 
 include(ExternalProject)
 find_package(Git)
 
+# Use GNUInstallDirs to provide the right locations on all platforms
+include(GNUInstallDirs)
+
 # creates a library GSL which is an interface (header files only)
 add_library(GSL INTERFACE)
 
@@ -51,13 +54,21 @@ target_compile_definitions(GSL INTERFACE
 )
 
 # add include folders to the library and targets that consume it
-target_include_directories(GSL INTERFACE
-    $<BUILD_INTERFACE:
-        ${CMAKE_CURRENT_SOURCE_DIR}/include
-    >
-)
+# the SYSTEM keyword suppresses warnings for users of the library
+if(GSL_STANDALONE_PROJECT)
+    target_include_directories(GSL INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+else()
+    target_include_directories(GSL SYSTEM INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+endif()
 
-if ((CMAKE_VERSION GREATER 3.7.9) OR (CMAKE_VERSION EQUAL 3.7.9))
+
+if (CMAKE_VERSION VERSION_GREATER 3.7.8)
     if (MSVC_IDE)
         option(VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
     else()
@@ -67,15 +78,23 @@ if ((CMAKE_VERSION GREATER 3.7.9) OR (CMAKE_VERSION EQUAL 3.7.9))
     # add natvis file to the library so it will automatically be loaded into Visual Studio
     if(VS_ADD_NATIVE_VISUALIZERS)
         target_sources(GSL INTERFACE
-            ${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis>
         )
     endif()
 endif()
 
+install(TARGETS GSL EXPORT Microsoft.GSLConfig)
 install(
     DIRECTORY include/gsl
-    DESTINATION include
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 )
+# Make library importable by other projects
+install(EXPORT Microsoft.GSLConfig NAMESPACE Microsoft.GSL:: DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
+export(TARGETS GSL NAMESPACE Microsoft.GSL:: FILE Microsoft.GSLConfig.cmake)
+
+# Add Microsoft.GSL::GSL alias for GSL so that dependents can be agnostic about
+# whether GSL was added via `add_subdirectory` or `find_package`
+add_library(Microsoft.GSL::GSL ALIAS GSL)
 
 option(GSL_TEST "Generate tests." ${GSL_STANDALONE_PROJECT})
 if (GSL_TEST)

CONTRIBUTING.md

@@ -1,6 +1,6 @@
-## Contributing to the Guideline Support Library
+## Contributing to the Guidelines Support Library
 
-The Guideline Support Library (GSL) contains functions and types that are suggested for use by the
+The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
 [C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines). GSL design changes are made only as a result of modifications to the Guidelines. 
 
 GSL is accepting contributions that improve or refine any of the types in this library as well as ports to other platforms. Changes should have an issue 

README.md

@@ -1,6 +1,6 @@
-# GSL: Guideline Support Library [![Build Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL) [![Build status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL)
+# GSL: Guidelines Support Library [![Build Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL) [![Build status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL)
 
-The Guideline Support Library (GSL) contains functions and types that are suggested for use by the
+The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
 [C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) maintained by the [Standard C++ Foundation](https://isocpp.org).
 This repo contains Microsoft's implementation of GSL.
 
@@ -18,7 +18,7 @@ other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more inform
 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.
+This project makes use of the [Google Test](https://github.com/google/googletest) testing library. Please see the [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) file for details regarding the licensing of Google Test.
 
 # Quick Start
 ## Supported Platforms
@@ -27,10 +27,17 @@ The test suite that exercises GSL has been built and passes successfully on the
 * Windows using Visual Studio 2015
 * Windows using Visual Studio 2017
 * Windows using Clang/LLVM 3.6
+* Windows using Clang/LLVM 7.0.0
 * Windows using GCC 5.1
 * Windows using Intel C++ Compiler 18.0
-* GNU/Linux using Clang/LLVM 3.6
+* GNU/Linux using Clang/LLVM 3.6-3.9
+* GNU/Linux using Clang/LLVM 4.0
+* GNU/Linux using Clang/LLVM 5.0
+* GNU/Linux using Clang/LLVM 6.0
+* GNU/Linux using Clang/LLVM 7.0
 * GNU/Linux using GCC 5.1
+* OS X Mojave 10.14.4 using Apple LLVM version 10.0.0 (10.0.1.10010046)
+* OS X Mojave 10.14.3 using Apple LLVM version 10.0.0 (clang-1000.11.45.5)
 * OS X Yosemite using Xcode with Apple Clang 7.0.0.7000072
 * OS X Yosemite using GCC-5.2.0
 * OS X Sierra 10.12.4 using Apple LLVM version 8.1.0 (Clang-802.0.42)
@@ -46,7 +53,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 3.1.3 or later to be installed and in your PATH.
+* [CMake](http://cmake.org), version 3.1.3 (3.2.3 for AppleClang) 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`.
 
@@ -70,6 +77,18 @@ These steps assume the source code of this repository has been cloned into a dir
 
 All tests should pass - indicating your platform is fully supported and you are ready to use the GSL types!
 
+## Building GSL - Using vcpkg
+
+You can download and install GSL using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install ms-gsl
+
+The GSL port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
 ## Using the libraries
 As the types are entirely implemented inline in headers, there are no linking requirements.
 
@@ -90,5 +109,14 @@ Include the library using:
 
     #include <gsl/gsl>
 
+## Usage in CMake
+
+The library provides a Config file for CMake, once installed it can be found via
+
+    find_package(Microsoft.GSL CONFIG)
+
+Which, when successful, will add library target called `Microsoft.GSL::GSL` which you can use via the usual
+`target_link_libraries` mechanism.
+
 ## Debugging visualization support
 For Visual Studio users, the file [GSL.natvis](./GSL.natvis) in the root directory of the repository can be added to your project if you would like more helpful visualization of GSL types in the Visual Studio debugger than would be offered by default.

ThirdPartyNotices.txt

@@ -2,38 +2,40 @@
 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.  
+GSL: Guidelines Support Library incorporates third party material from the projects listed below.
 
+-------------------------------------------------------------------------------
+Software: Google Test
+Owner: Google Inc.
+Source URL: github.com/google/googletest
+License: BSD 3 - Clause
+Text:
+    Copyright 2008, Google Inc.
+    All rights reserved.
 
-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
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
 
+        * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+        * Neither the name of Google Inc. nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
 
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-------------------------------------------------------------------------------

appveyor.yml

@@ -11,46 +11,116 @@ configuration:
 image:
   - Visual Studio 2015
   - Visual Studio 2017
+  - Visual Studio 2019
 
 environment:
+  NINJA_TAG: v1.8.2
+  NINJA_SHA512: 9B9CE248240665FCD6404B989F3B3C27ED9682838225E6DC9B67B551774F251E4FF8A207504F941E7C811E7A8BE1945E7BCB94472A335EF15E23A0200A32E6D5
+  NINJA_PATH: C:\Tools\ninja\ninja-%NINJA_TAG%
+  VCVAR2015: 'C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat'
+  VCVAR2017: 'C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat'
+  VCVAR2019: 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsall.bat'
   matrix:
     - GSL_CXX_STANDARD: 14
+      USE_TOOLSET: MSVC
+      USE_GENERATOR: MSBuild
     - GSL_CXX_STANDARD: 17
+      USE_TOOLSET: MSVC
+      USE_GENERATOR: MSBuild
+    - GSL_CXX_STANDARD: 14
+      USE_TOOLSET: LLVM
+      USE_GENERATOR: Ninja
+    - GSL_CXX_STANDARD: 17
+      USE_TOOLSET: LLVM
+      USE_GENERATOR: Ninja
 
 matrix:
     exclude:
     - image: Visual Studio 2015
       GSL_CXX_STANDARD: 17
+    - image: Visual Studio 2015
+      USE_TOOLSET: LLVM
+      USE_GENERATOR: MSBuild
 
 cache:
-  - C:\cmake-3.8.0-win32-x86
+  - C:\cmake-3.14.4-win32-x86
+  - C:\Tools\ninja
 
 install:
   - ps: |
-      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:\
+      if (![IO.File]::Exists("$env:NINJA_PATH\ninja.exe")) {
+        Start-FileDownload `
+          "https://github.com/ninja-build/ninja/releases/download/$env:NINJA_TAG/ninja-win.zip"
+        $hash = (Get-FileHash ninja-win.zip -Algorithm SHA512).Hash
+        if ($env:NINJA_SHA512 -eq $hash) {
+          7z e -y -bso0 ninja-win.zip -o"$env:NINJA_PATH"
+        } else { Write-Warning "Ninja download hash changed!"; Write-Output "$hash" }
+      }
+      if ([IO.File]::Exists("$env:NINJA_PATH\ninja.exe")) {
+        $env:PATH = "$env:NINJA_PATH;$env:PATH"
+      } else { Write-Warning "Failed to find ninja.exe in expected location." }
+      if ($env:USE_TOOLSET -ne "LLVM") {
+        if (![IO.File]::Exists("C:\cmake-3.14.0-win32-x86\bin\cmake.exe")) {
+          Start-FileDownload 'https://cmake.org/files/v3.14/cmake-3.14.4-win32-x86.zip'
+          7z x -y -bso0 cmake-3.14.4-win32-x86.zip -oC:\
+        }
+        $env:PATH="C:\cmake-3.14.4-win32-x86\bin;$env:PATH"
       }
-      $env:PATH="C:\cmake-3.8.0-win32-x86\bin;$env:PATH"
 
 before_build:
   - ps: |
-      mkdir build
-      cd build
-
-      if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2015") {
-          $env:generator="Visual Studio 14 2015"
+      if ("$env:USE_GENERATOR" -eq "Ninja") {
+        $GeneratorFlags = '-k 10'
+        $Architecture = $env:PLATFORM
+        if ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2015") {
+          $env:VCVARSALL = "`"$env:VCVAR2015`" $Architecture"
+        } elseif ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2017") {
+          $env:VCVARSALL = "`"$env:VCVAR2017`" $Architecture"
+        } else {
+          $env:VCVARSALL = "`"$env:VCVAR2019`" $Architecture"
+        }
+        $env:CMakeGenFlags = "-G Ninja -DGSL_CXX_STANDARD=$env:GSL_CXX_STANDARD"
       } else {
-          $env:generator="Visual Studio 15 2017"
+        $GeneratorFlags = '/m /v:minimal'
+        if ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2015") {
+          $Generator = 'Visual Studio 14 2015'
+        } elseif ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2017") {
+          $Generator = 'Visual Studio 15 2017'
+        } else {
+          $Generator = 'Visual Studio 16 2019'
+        }
+        if ("$env:PLATFORM" -eq "x86") { 
+            $Architecture = "Win32"
+        } else { 
+            $Architecture = "x64" 
+        }
+        if ("$env:USE_TOOLSET" -eq "LLVM") {
+          $env:CMakeGenFlags = "-G `"$Generator`" -A $Architecture -T llvm -DGSL_CXX_STANDARD=$env:GSL_CXX_STANDARD"
+        } else {
+          $env:CMakeGenFlags = "-G `"$Generator`" -A $Architecture -DGSL_CXX_STANDARD=$env:GSL_CXX_STANDARD"
+        }
       }
-      if ($env:PLATFORM -eq "x64") {
-          $env:generator="$env:generator Win64"
+      if ("$env:USE_TOOLSET" -eq "LLVM") {
+        $env:CC  = "clang-cl"
+        $env:CXX = "clang-cl"
+        if ("$env:PLATFORM" -eq "x86") {
+          $env:CFLAGS   = "-m32";
+          $env:CXXFLAGS = "-m32";
+        } else {
+          $env:CFLAGS   = "-m64";
+          $env:CXXFLAGS = "-m64";
+        }
       }
-      echo generator="$env:generator"
-      cmake .. -G "$env:generator" -DGSL_CXX_STANDARD="$env:GSL_CXX_STANDARD"
+      $env:CMakeBuildFlags = "--config $env:CONFIGURATION -- $GeneratorFlags"
+  - mkdir build
+  - cd build
+  - if %USE_GENERATOR%==Ninja (call %VCVARSALL%)
+  - echo %CMakeGenFlags%
+  - cmake .. %CMakeGenFlags%
 
 build_script:
-  - cmake --build . --config %CONFIGURATION% -- /m /v:minimal
+  - echo %CMakeBuildFlags%
+  - cmake --build . %CMakeBuildFlags%
 
 test_script:
   - ctest -j2

include/gsl/gsl_algorithm

@@ -37,8 +37,8 @@ namespace gsl
 {
 // Note: this will generate faster code than std::copy using span iterator in older msvc+stl
 // not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)
-template <class SrcElementType, std::ptrdiff_t SrcExtent, class DestElementType,
-          std::ptrdiff_t DestExtent>
+template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
+          std::size_t DestExtent>
 void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
 {
     static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,

include/gsl/gsl_assert

@@ -17,45 +17,40 @@
 #ifndef GSL_CONTRACTS_H
 #define GSL_CONTRACTS_H
 
-#include <exception>
-#include <stdexcept> // for logic_error
-
-//
-// make suppress attributes parse for some compilers
-// Hopefully temporary until suppresion standardization occurs
-//
-#if defined (_MSC_VER)
-#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
-#else
-#if defined(__clang__)
-#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
-#else
-#define GSL_SUPPRESS(x)
-#endif // __clang__
-#endif // _MSC_VER
-
 //
 // Temporary until MSVC STL supports no-exceptions mode.
 // Currently terminate is a no-op in this mode, so we add termination behavior back
 //
-#if defined(_MSC_VER) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
+#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+
 #define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
 #include <intrin.h>
 #define RANGE_CHECKS_FAILURE 0
-#endif
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-noreturn"
+#endif // defined(__clang__)
+
+#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+
+#include <exception>
+
+#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
 
 //
-// There are three configuration options for this GSL implementation's behavior
-// when pre/post conditions on the GSL types are violated:
+// make suppress attributes parse for some compilers
+// Hopefully temporary until suppression standardization occurs
 //
-// 1. GSL_TERMINATE_ON_CONTRACT_VIOLATION: std::terminate will be called (default)
-// 2. GSL_THROW_ON_CONTRACT_VIOLATION: a gsl::fail_fast exception will be thrown
-// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens
-//
-#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) || defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ||  \
-      defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION))
-#define GSL_TERMINATE_ON_CONTRACT_VIOLATION
-#endif
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#endif // _MSC_VER
+#endif // __clang__
 
 #define GSL_STRINGIFY_DETAIL(x) #x
 #define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)
@@ -63,10 +58,12 @@
 #if defined(__clang__) || defined(__GNUC__)
 #define GSL_LIKELY(x) __builtin_expect(!!(x), 1)
 #define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)
+
 #else
+
 #define GSL_LIKELY(x) (!!(x))
 #define GSL_UNLIKELY(x) (!!(x))
-#endif
+#endif // defined(__clang__) || defined(__GNUC__)
 
 //
 // GSL_ASSUME(cond)
@@ -88,18 +85,16 @@
 
 namespace gsl
 {
-struct fail_fast : public std::logic_error
-{
-    explicit fail_fast(char const* const message) : std::logic_error(message) {}
-};
 
 namespace details
 {
 #if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
 
-    typedef void  (__cdecl *terminate_handler)();
-    
+    typedef void(__cdecl* terminate_handler)();
+
+    // clang-format off
     GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
+    // clang-format on
     [[noreturn]] inline void __cdecl default_terminate_handler()
     {
         __fastfail(RANGE_CHECKS_FAILURE);
@@ -111,7 +106,7 @@ namespace details
         return handler;
     }
 
-#endif
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
 
     [[noreturn]] inline void terminate() noexcept
     {
@@ -119,49 +114,20 @@ namespace details
         (*gsl::details::get_terminate_handler())();
 #else
         std::terminate();
-#endif
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
     }
 
-#if defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
-
-    template <typename Exception>
-    [[noreturn]] void throw_exception(Exception&&) noexcept
-    {
-        gsl::details::terminate();
-    }
-
-#else
-
-    template <typename Exception>
-    [[noreturn]] void throw_exception(Exception&& exception)
-    {
-        throw std::forward<Exception>(exception);
-    }
-
-#endif
-
 } // namespace details
 } // namespace gsl
 
-#if defined(GSL_THROW_ON_CONTRACT_VIOLATION)
-
-#define GSL_CONTRACT_CHECK(type, cond)                                                             \
-    (GSL_LIKELY(cond) ? static_cast<void>(0)                                                       \
-                      : gsl::details::throw_exception(gsl::fail_fast(                              \
-                            "GSL: " type " failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__))))
-
-#elif defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
-
 #define GSL_CONTRACT_CHECK(type, cond)                                                             \
     (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
 
-#elif defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)
-
-#define GSL_CONTRACT_CHECK(type, cond) GSL_ASSUME(cond)
-
-#endif
-
 #define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)
 #define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)
 
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 #endif // GSL_CONTRACTS_H

include/gsl/gsl_byte

@@ -19,20 +19,22 @@
 
 //
 // make suppress attributes work for some compilers
-// Hopefully temporary until suppresion standardization occurs
+// Hopefully temporary until suppression standardization occurs
 //
-#if defined(_MSC_VER)
-#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
-#else
 #if defined(__clang__)
 #define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
 #else
+#if defined(_MSC_VER)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
 #define GSL_SUPPRESS(x)
-#endif // __clang__
 #endif // _MSC_VER
+#endif // __clang__
 
 #include <type_traits>
 
+// VS2017 15.8 added support for the __cpp_lib_byte definition
+// To do: drop _HAS_STD_BYTE when support for pre 15.8 expires
 #ifdef _MSC_VER
 
 #pragma warning(push)
@@ -42,20 +44,21 @@
 
 #ifndef GSL_USE_STD_BYTE
 // this tests if we are under MSVC and the standard lib has std::byte and it is enabled
-#if defined(_HAS_STD_BYTE) && _HAS_STD_BYTE
+#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
 
 #define GSL_USE_STD_BYTE 1
 
-#else // defined(_HAS_STD_BYTE) && _HAS_STD_BYTE
+#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
 
 #define GSL_USE_STD_BYTE 0
 
-#endif // defined(_HAS_STD_BYTE) && _HAS_STD_BYTE
+#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
 #endif // GSL_USE_STD_BYTE
 
 #else // _MSC_VER
 
 #ifndef GSL_USE_STD_BYTE
+#include <cstddef> /* __cpp_lib_byte */
 // this tests if we are under GCC or Clang with enough -std:c++1z power to get us std::byte
 // also check if libc++ version is sufficient (> 5.0) or libstc++ actually contains std::byte
 #if defined(__cplusplus) && (__cplusplus >= 201703L) && \
@@ -63,7 +66,6 @@
    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
 
 #define GSL_USE_STD_BYTE 1
-#include <cstddef>
 
 #else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
@@ -79,12 +81,16 @@
 #endif // _MSC_VER
 
 // Use __may_alias__ attribute on gcc and clang
-#if defined __clang__ || (__GNUC__ > 5)
+#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)
 #define byte_may_alias __attribute__((__may_alias__))
 #else // defined __clang__ || defined __GNUC__
 #define byte_may_alias
 #endif // defined __clang__ || defined __GNUC__
 
+#if GSL_USE_STD_BYTE
+#include <cstddef>
+#endif
+
 namespace gsl
 {
 #if GSL_USE_STD_BYTE

include/gsl/gsl_util

@@ -21,12 +21,11 @@
 
 #include <array>
 #include <cstddef>          // for ptrdiff_t, size_t
-#include <exception>        // for exception
 #include <initializer_list> // for initializer_list
 #include <type_traits>      // for is_signed, integral_constant
-#include <utility>          // for forward
+#include <utility>          // for exchange, forward
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
 
 #pragma warning(push)
 #pragma warning(disable : 4127) // conditional expression is constant
@@ -37,6 +36,12 @@
 #endif            // _MSC_VER < 1910
 #endif            // _MSC_VER
 
+#if (defined(_MSC_VER) && _MSC_VER < 1910) || (!defined(__clang__) && defined(__GNUC__) && __GNUC__ < 6)
+#define GSL_CONSTEXPR_NARROW 0
+#else
+#define GSL_CONSTEXPR_NARROW 1
+#endif
+
 namespace gsl
 {
 //
@@ -53,10 +58,7 @@ class final_action
 public:
     explicit final_action(F f) noexcept : f_(std::move(f)) {}
 
-    final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_)
-    {
-        other.invoke_ = false;
-    }
+    final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(std::exchange(other.invoke_, false)) {}
 
     final_action(const final_action&) = delete;
     final_action& operator=(const final_action&) = delete;
@@ -111,12 +113,15 @@ namespace details
 template <class T, class U>
 GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
 GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+#if GSL_CONSTEXPR_NARROW
+constexpr
+#endif
 T narrow(U u) noexcept(false)
 {
     T t = narrow_cast<T>(u);
-    if (static_cast<U>(t) != u) gsl::details::throw_exception(narrowing_error());
+    if (static_cast<U>(t) != u) throw narrowing_error{};
     if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
-        gsl::details::throw_exception(narrowing_error());
+        throw narrowing_error{};
     return t;
 }
 
@@ -152,7 +157,7 @@ constexpr T at(const std::initializer_list<T> cont, const index i)
 
 } // namespace gsl
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
 #if _MSC_VER < 1910
 #undef constexpr
 #pragma pop_macro("constexpr")

include/gsl/multi_span

@@ -23,8 +23,7 @@
 
 #include <algorithm> // for transform, lexicographical_compare
 #include <array>     // for array
-#include <cassert>
-#include <cstddef>          // for ptrdiff_t, size_t, nullptr_t
+#include <cstddef>          // for std::ptrdiff_t, size_t, nullptr_t
 #include <cstdint>          // for PTRDIFF_MAX
 #include <functional>       // for divides, multiplies, minus, negate, plus
 #include <initializer_list> // for initializer_list
@@ -37,7 +36,7 @@
 #include <type_traits> // for enable_if_t, remove_cv_t, is_same, is_co...
 #include <utility>
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 
 // turn off some warnings that are noisy about our Expects statements
 #pragma warning(push)
@@ -49,20 +48,26 @@
 #pragma warning(disable : 26473) // in some instantiations we cast to the same type
 #pragma warning(disable : 26490) // TODO: bug in parser - attributes and templates
 #pragma warning(disable : 26465) // TODO: bug - suppression does not work on template functions
+#pragma warning(disable : 4996)  // use of function or classes marked [[deprecated]]
 
 #if _MSC_VER < 1910
 #pragma push_macro("constexpr")
 #define constexpr /*constexpr*/
 
-#endif                          // _MSC_VER < 1910
-#endif                          // _MSC_VER
+#endif // _MSC_VER < 1910
+#endif // _MSC_VER
 
-// GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t)
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+// GCC 7 does not like the signed unsigned missmatch (size_t std::ptrdiff_t)
 // While there is a conversion from signed to unsigned, it happens at
 // compiletime, so the compiler wouldn't have to warn indiscriminently, but
 // could check if the source value actually doesn't fit into the target type
 // and only warn in those cases.
-#if __GNUC__ > 6
+#if defined(__GNUC__) && __GNUC__ > 6
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
@@ -76,18 +81,18 @@ namespace gsl
 namespace details
 {
     template <typename SizeType>
-    struct SizeTypeTraits
+    struct [[deprecated]] SizeTypeTraits
     {
         static const SizeType max_value = std::numeric_limits<SizeType>::max();
     };
 
     template <typename... Ts>
-    class are_integral : public std::integral_constant<bool, true>
+    class [[deprecated]] are_integral : public std::integral_constant<bool, true>
     {
     };
 
     template <typename T, typename... Ts>
-    class are_integral<T, Ts...>
+    class [[deprecated]] are_integral<T, Ts...>
         : public std::integral_constant<bool,
                                         std::is_integral<T>::value && are_integral<Ts...>::value>
     {
@@ -95,8 +100,7 @@ namespace details
 } // namespace details
 
 template <std::size_t Rank>
-class multi_span_index final
-{
+class [[deprecated]] multi_span_index final {
     static_assert(Rank > 0, "Rank must be greater than 0!");
 
     template <std::size_t OtherRank>
@@ -111,7 +115,7 @@ public:
 
     constexpr multi_span_index() noexcept {}
 
-    constexpr multi_span_index(const value_type (&values)[Rank]) noexcept
+    constexpr multi_span_index(const value_type(&values)[Rank]) noexcept
     {
         GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
         GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
@@ -139,7 +143,7 @@ public:
     // Preconditions: component_idx < rank
     GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
     GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    constexpr const_reference operator[](std::size_t component_idx) const 
+    constexpr const_reference operator[](std::size_t component_idx) const
     {
         Expects(component_idx < Rank); // Component index must be less than rank
         return elems[component_idx];
@@ -152,10 +156,7 @@ public:
         return std::equal(elems, elems + rank, rhs.elems);
     }
 
-    constexpr bool operator!=(const multi_span_index& rhs) const
-    {
-        return !(*this == rhs);
-    }
+    constexpr bool operator!=(const multi_span_index& rhs) const { return !(*this == rhs); }
 
     constexpr multi_span_index operator+() const noexcept { return *this; }
 
@@ -184,8 +185,7 @@ public:
     {
         GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
         GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-        std::transform(elems, elems + rank, rhs.elems, elems,
-                       std::plus<value_type>{});
+        std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{});
         return *this;
     }
 
@@ -240,7 +240,7 @@ private:
 
 #if !defined(_MSC_VER) || _MSC_VER >= 1910
 
-struct static_bounds_dynamic_range_t
+struct [[deprecated]] static_bounds_dynamic_range_t
 {
     template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
     constexpr operator T() const noexcept
@@ -288,25 +288,22 @@ constexpr static_bounds_dynamic_range_t dynamic_range{};
 const std::ptrdiff_t dynamic_range = -1;
 #endif
 
-struct generalized_mapping_tag
-{
-};
-struct contiguous_mapping_tag : generalized_mapping_tag
+struct [[deprecated]] generalized_mapping_tag
 {
 };
+struct[[deprecated]] contiguous_mapping_tag : generalized_mapping_tag{};
 
 namespace details
 {
 
     template <std::ptrdiff_t Left, std::ptrdiff_t Right>
-    struct LessThan
+    struct [[deprecated]] LessThan
     {
         static const bool value = Left < Right;
     };
 
     template <std::ptrdiff_t... Ranges>
-    struct BoundsRanges
-    {
+    struct [[deprecated]] BoundsRanges {
         using size_type = std::ptrdiff_t;
         static const size_type Depth = 0;
         static const size_type DynamicNum = 0;
@@ -315,37 +312,37 @@ namespace details
 
         // TODO : following signature is for work around VS bug
         template <typename OtherRange>
-        BoundsRanges(const OtherRange&, bool /* firstLevel */)
+        constexpr BoundsRanges(const OtherRange&, bool /* firstLevel */)
         {}
 
-        BoundsRanges(const std::ptrdiff_t* const) {}
-        BoundsRanges() noexcept = default;
+        constexpr BoundsRanges(const std::ptrdiff_t* const) {}
+        constexpr BoundsRanges() noexcept = default;
 
         template <typename T, std::size_t Dim>
-        void serialize(T&) const
+        constexpr void serialize(T&) const
         {}
 
         template <typename T, std::size_t Dim>
-        size_type linearize(const T&) const
+        constexpr size_type linearize(const T&) const
         {
             return 0;
         }
 
         template <typename T, std::size_t Dim>
-        size_type contains(const T&) const
+        constexpr size_type contains(const T&) const
         {
             return -1;
         }
 
-        size_type elementNum(std::size_t) const noexcept { return 0; }
+        constexpr size_type elementNum(std::size_t) const noexcept { return 0; }
 
-        size_type totalSize() const noexcept { return TotalSize; }
+        constexpr size_type totalSize() const noexcept { return TotalSize; }
 
-        bool operator==(const BoundsRanges&) const noexcept { return true; }
+        constexpr bool operator==(const BoundsRanges&) const noexcept { return true; }
     };
 
     template <std::ptrdiff_t... RestRanges>
-    struct BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...>
+    struct[[deprecated]] BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...>
     {
         using Base = BoundsRanges<RestRanges...>;
         using size_type = std::ptrdiff_t;
@@ -358,25 +355,26 @@ namespace details
         size_type m_bound;
 
     public:
-        GSL_SUPPRESS(f.23) // NO-FORMAT: attribute // this pointer type is cannot be assigned nullptr - issue in not_null
-        GSL_SUPPRESS(bounds.1)  // NO-FORMAT: attribute
-        BoundsRanges(const std::ptrdiff_t* const arr)
+        GSL_SUPPRESS(
+            f.23) // NO-FORMAT: attribute // this pointer type is cannot be assigned nullptr - issue in not_null
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        constexpr BoundsRanges(const std::ptrdiff_t* const arr)
             : Base(arr + 1), m_bound(*arr * this->Base::totalSize())
         {
             Expects(0 <= *arr);
         }
 
-        BoundsRanges() noexcept : m_bound(0) {}
+        constexpr BoundsRanges() noexcept : m_bound(0) {}
 
         template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges>
-        BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
-                     bool /* firstLevel */ = true)
+        constexpr BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
+                               bool /* firstLevel */ = true)
             : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
             , m_bound(other.totalSize())
         {}
 
         template <typename T, std::size_t Dim = 0>
-        void serialize(T& arr) const
+        constexpr void serialize(T & arr) const
         {
             arr[Dim] = elementNum();
             this->Base::template serialize<T, Dim + 1>(arr);
@@ -384,7 +382,7 @@ namespace details
 
         template <typename T, std::size_t Dim = 0>
         GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-        size_type linearize(const T& arr) const
+        constexpr size_type linearize(const T& arr) const
         {
             const size_type index = this->Base::totalSize() * arr[Dim];
             Expects(index < m_bound);
@@ -392,27 +390,28 @@ namespace details
         }
 
         template <typename T, std::size_t Dim = 0>
-        size_type contains(const T& arr) const
+        constexpr size_type contains(const T& arr) const
         {
-            const ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr);
+            const std::ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr);
             if (last == -1) return -1;
-            const ptrdiff_t cur = this->Base::totalSize() * arr[Dim];
+            const std::ptrdiff_t cur = this->Base::totalSize() * arr[Dim];
             return cur < m_bound ? cur + last : -1;
         }
 
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        size_type totalSize() const noexcept
-        {
-            return m_bound;
-        }
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
+        constexpr size_type totalSize() const noexcept { return m_bound; }
 
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        size_type elementNum() const noexcept
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
+        constexpr size_type elementNum() const noexcept
         {
             return totalSize() / this->Base::totalSize();
         }
 
-        size_type elementNum(std::size_t dim) const noexcept
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
+        constexpr size_type elementNum(std::size_t dim) const noexcept
         {
             if (dim > 0)
                 return this->Base::elementNum(dim - 1);
@@ -420,7 +419,7 @@ namespace details
                 return elementNum();
         }
 
-        bool operator==(const BoundsRanges& rhs) const noexcept
+        constexpr bool operator==(const BoundsRanges& rhs) const noexcept
         {
             return m_bound == rhs.m_bound &&
                    static_cast<const Base&>(*this) == static_cast<const Base&>(rhs);
@@ -428,7 +427,7 @@ namespace details
     };
 
     template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges>
-    struct BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...>
+    struct[[deprecated]] BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...>
     {
         using Base = BoundsRanges<RestRanges...>;
         using size_type = std::ptrdiff_t;
@@ -438,12 +437,12 @@ namespace details
         static const size_type TotalSize =
             Base::TotalSize == dynamic_range ? dynamic_range : CurrentRange * Base::TotalSize;
 
-        BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {}
-        BoundsRanges() = default;
+        constexpr BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {}
+        constexpr BoundsRanges() = default;
 
         template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges>
-        BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
-                     bool firstLevel = true)
+        constexpr BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
+                               bool firstLevel = true)
             : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
         {
             GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: false positive
@@ -451,25 +450,24 @@ namespace details
         }
 
         template <typename T, std::size_t Dim = 0>
-        void serialize(T& arr) const
+        constexpr void serialize(T & arr) const
         {
             arr[Dim] = elementNum();
             this->Base::template serialize<T, Dim + 1>(arr);
         }
 
         template <typename T, std::size_t Dim = 0>
-        size_type linearize(const T& arr) const
+        constexpr size_type linearize(const T& arr) const
         {
-            GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+            GSL_SUPPRESS(bounds.4)                            // NO-FORMAT: attribute
             Expects(arr[Dim] >= 0 && arr[Dim] < CurrentRange); // Index is out of range
-
-            GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-            return this->Base::totalSize() * arr[Dim] +
-                   this->Base::template linearize<T, Dim + 1>(arr);
+            GSL_SUPPRESS(bounds.4)                            // NO-FORMAT: attribute
+            const std::ptrdiff_t d = arr[Dim];
+            return this->Base::totalSize() * d + this->Base::template linearize<T, Dim + 1>(arr);
         }
 
         template <typename T, std::size_t Dim = 0>
-        size_type contains(const T& arr) const
+        constexpr size_type contains(const T& arr) const
         {
             if (arr[Dim] >= CurrentRange) return -1;
             const size_type last = this->Base::template contains<T, Dim + 1>(arr);
@@ -477,20 +475,20 @@ namespace details
             return this->Base::totalSize() * arr[Dim] + last;
         }
 
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        size_type totalSize() const noexcept
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
+        constexpr size_type totalSize() const noexcept
         {
             return CurrentRange * this->Base::totalSize();
         }
 
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        size_type elementNum() const noexcept
-        {
-            return CurrentRange;
-        }
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
+        constexpr size_type elementNum() const noexcept { return CurrentRange; }
 
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        size_type elementNum(std::size_t dim) const noexcept
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
+        constexpr size_type elementNum(std::size_t dim) const noexcept
         {
             if (dim > 0)
                 return this->Base::elementNum(dim - 1);
@@ -498,50 +496,47 @@ namespace details
                 return elementNum();
         }
 
-        bool operator==(const BoundsRanges& rhs) const noexcept
+        constexpr bool operator==(const BoundsRanges& rhs) const noexcept
         {
             return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs);
         }
     };
 
     template <typename SourceType, typename TargetType>
-    struct BoundsRangeConvertible
+    struct[[deprecated]] BoundsRangeConvertible
         : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize ||
                                                TargetType::TotalSize == dynamic_range ||
                                                SourceType::TotalSize == dynamic_range ||
-                                               TargetType::TotalSize == 0)>
-    {
-    };
+                                               TargetType::TotalSize == 0)>{};
 
     template <typename TypeChain>
-    struct TypeListIndexer
-    {
+    struct [[deprecated]] TypeListIndexer {
         const TypeChain& obj_;
-        TypeListIndexer(const TypeChain& obj) : obj_(obj) {}
+        constexpr TypeListIndexer(const TypeChain& obj) : obj_(obj) {}
 
         template <std::size_t N>
-        const TypeChain& getObj(std::true_type)
+        constexpr const TypeChain& getObj(std::true_type)
         {
             return obj_;
         }
 
         template <std::size_t N, typename MyChain = TypeChain,
                   typename MyBase = typename MyChain::Base>
-        auto getObj(std::false_type)
-            -> decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>())
+        constexpr auto getObj(std::false_type)
+            ->decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>())
         {
             return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>();
         }
 
         template <std::size_t N>
-        auto get() -> decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>()))
+        constexpr auto get()->decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>()))
         {
             return getObj<N - 1>(std::integral_constant<bool, N == 0>());
         }
     };
 
     template <typename TypeChain>
-    TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj)
+    constexpr TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj)
     {
         return TypeListIndexer<TypeChain>(obj);
     }
@@ -554,24 +549,23 @@ namespace details
         for (std::size_t i = 0; i < Rank - 1; ++i)
         {
             GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-                ret[i] = other[i + 1];
+            ret[i] = other[i + 1];
         }
         return ret;
     }
 } // namespace details
 
 template <typename IndexType>
-class bounds_iterator;
+class [[deprecated]] bounds_iterator;
 
 template <std::ptrdiff_t... Ranges>
-class static_bounds
-{
+class [[deprecated]] static_bounds {
 public:
     static_bounds(const details::BoundsRanges<Ranges...>&) {}
 };
 
 template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges>
-class static_bounds<FirstRange, RestRanges...>
+class[[deprecated]] static_bounds<FirstRange, RestRanges...>
 {
     using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>;
 
@@ -595,7 +589,6 @@ public:
     using sliced_type = static_bounds<RestRanges...>;
     using mapping_type = contiguous_mapping_tag;
 
-    constexpr static_bounds(const static_bounds&) noexcept = default;
     constexpr static_bounds() /*noexcept*/ = default;
 
     template <typename SourceType, typename TargetType, std::size_t Rank>
@@ -604,10 +597,10 @@ public:
     template <std::size_t Rank, typename SourceType, typename TargetType,
               typename Ret = BoundsRangeConvertible2<typename SourceType::Base,
                                                      typename TargetType::Base, Rank>>
-    static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret;
+    static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type)->Ret;
 
     template <std::size_t Rank, typename SourceType, typename TargetType>
-    static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type;
+    static auto helpBoundsRangeConvertible(SourceType, TargetType, ...)->std::false_type;
 
     template <typename SourceType, typename TargetType, std::size_t Rank>
     struct BoundsRangeConvertible2
@@ -724,10 +717,7 @@ public:
         return !(*this == rhs);
     }
 
-    constexpr const_iterator begin() const noexcept
-    {
-        return const_iterator(*this, index_type{});
-    }
+    constexpr const_iterator begin() const noexcept { return const_iterator(*this, index_type{}); }
 
     constexpr const_iterator end() const noexcept
     {
@@ -736,7 +726,7 @@ public:
 };
 
 template <std::size_t Rank>
-class strided_bounds {
+class [[deprecated]] strided_bounds {
     template <std::size_t OtherRank>
     friend class strided_bounds;
 
@@ -760,14 +750,13 @@ public:
 
     constexpr strided_bounds& operator=(const strided_bounds&) noexcept = default;
 
-    constexpr strided_bounds(const value_type (&values)[rank], index_type strides)
+    constexpr strided_bounds(const value_type(&values)[rank], index_type strides)
         : m_extents(values), m_strides(std::move(strides))
     {}
 
     constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept
         : m_extents(extents), m_strides(strides)
-    {
-    }
+    {}
 
     constexpr index_type strides() const noexcept { return m_strides; }
 
@@ -839,21 +828,14 @@ private:
 };
 
 template <typename T>
-struct is_bounds : std::integral_constant<bool, false>
-{
-};
+struct[[deprecated]] is_bounds : std::integral_constant<bool, false>{};
 template <std::ptrdiff_t... Ranges>
-struct is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true>
-{
-};
+struct[[deprecated]] is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true>{};
 template <std::size_t Rank>
-struct is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>
-{
-};
+struct[[deprecated]] is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>{};
 
 template <typename IndexType>
-class bounds_iterator
-{
+class [[deprecated]] bounds_iterator {
 public:
     static const std::size_t rank = IndexType::rank;
     using iterator_category = std::random_access_iterator_tag;
@@ -974,7 +956,6 @@ public:
         return curr_ == rhs.curr_;
     }
 
-
     constexpr bool operator!=(const bounds_iterator& rhs) const noexcept { return !(*this == rhs); }
 
     constexpr bool operator<(const bounds_iterator& rhs) const noexcept
@@ -988,16 +969,15 @@ public:
 
     constexpr bool operator>=(const bounds_iterator& rhs) const noexcept { return !(rhs > *this); }
 
-    void swap(bounds_iterator& rhs) noexcept
+    void swap(bounds_iterator & rhs) noexcept
     {
         std::swap(boundary_, rhs.boundary_);
         std::swap(curr_, rhs.curr_);
     }
 
 private:
-
     GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    constexpr bool less(index_type& one, index_type& other) const noexcept
+    constexpr bool less(index_type & one, index_type & other) const noexcept
     {
         for (std::size_t i = 0; i < rank; ++i)
         {
@@ -1092,17 +1072,17 @@ namespace details
 } // namespace details
 
 template <typename Span>
-class contiguous_span_iterator;
+class [[deprecated]] contiguous_span_iterator;
 template <typename Span>
-class general_span_iterator;
+class [[deprecated]] general_span_iterator;
 
 template <std::ptrdiff_t DimSize = dynamic_range>
-struct dim_t
+struct [[deprecated]] dim_t
 {
     static const std::ptrdiff_t value = DimSize;
 };
 template <>
-struct dim_t<dynamic_range>
+struct [[deprecated]] dim_t<dynamic_range>
 {
     static const std::ptrdiff_t value = dynamic_range;
     const std::ptrdiff_t dvalue;
@@ -1123,28 +1103,30 @@ constexpr dim_t<N> dim(std::ptrdiff_t n) noexcept
 
 template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
           std::ptrdiff_t... RestDimensions>
-class multi_span;
+class [[deprecated("gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span;
+
 template <typename ValueType, std::size_t Rank>
-class strided_span;
+class [[deprecated("gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span;
 
 namespace details
 {
     template <typename T, typename = std::true_type>
-    struct SpanTypeTraits
+    struct [[deprecated]] SpanTypeTraits
     {
         using value_type = T;
         using size_type = std::size_t;
     };
 
     template <typename Traits>
-    struct SpanTypeTraits<Traits, typename std::is_reference<typename Traits::span_traits&>::type>
+    struct [[deprecated]] SpanTypeTraits<
+        Traits, typename std::is_reference<typename Traits::span_traits&>::type>
     {
         using value_type = typename Traits::span_traits::value_type;
         using size_type = typename Traits::span_traits::size_type;
     };
 
     template <typename T, std::ptrdiff_t... Ranks>
-    struct SpanArrayTraits
+    struct [[deprecated]] SpanArrayTraits
     {
         using type = multi_span<T, Ranks...>;
         using value_type = T;
@@ -1153,7 +1135,7 @@ namespace details
         using reference = T&;
     };
     template <typename T, std::ptrdiff_t N, std::ptrdiff_t... Ranks>
-    struct SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N>
+    struct [[deprecated]] SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N>
     {
     };
 
@@ -1177,7 +1159,7 @@ namespace details
             totalSize, std::integral_constant<bool, BoundsType::dynamic_rank == 1>());
     }
 
-    struct Sep
+    struct [[deprecated]] Sep
     {
     };
 
@@ -1200,36 +1182,35 @@ namespace details
     }
 
     template <typename... Dimensions>
-    struct static_as_multi_span_static_bounds_helper
+    struct [[deprecated]] static_as_multi_span_static_bounds_helper
     {
         using type = static_bounds<(Dimensions::value)...>;
     };
 
     template <typename T>
-    struct is_multi_span_oracle : std::false_type
+    struct [[deprecated]] is_multi_span_oracle : std::false_type
     {
     };
 
     template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>>
+    struct [[deprecated]] is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>>
         : std::true_type
     {
     };
 
     template <typename ValueType, std::ptrdiff_t Rank>
-    struct is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type
+    struct [[deprecated]] is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type
     {
     };
 
     template <typename T>
-    struct is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>>
+    struct [[deprecated]] is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>>
     {
     };
 } // namespace details
 
 template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-class multi_span
-{
+class [[deprecated("gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span {
     // TODO do we still need this?
     template <typename ValueType2, std::ptrdiff_t FirstDimension2,
               std::ptrdiff_t... RestDimensions2>
@@ -1262,8 +1243,7 @@ private:
 public:
     // default constructor - same as constructing from nullptr_t
     GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    constexpr multi_span() noexcept
-        : multi_span(nullptr, bounds_type{})
+    constexpr multi_span() noexcept : multi_span(nullptr, bounds_type{})
     {
         static_assert(bounds_type::dynamic_rank != 0 ||
                           (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
@@ -1273,8 +1253,7 @@ public:
 
     // construct from nullptr - get an empty multi_span
     GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    constexpr multi_span(std::nullptr_t) noexcept
-        : multi_span(nullptr, bounds_type{})
+    constexpr multi_span(std::nullptr_t) noexcept : multi_span(nullptr, bounds_type{})
     {
         static_assert(bounds_type::dynamic_rank != 0 ||
                           (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
@@ -1298,8 +1277,7 @@ public:
     // construct from a single element
 
     GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    constexpr multi_span(reference data) noexcept
-        : multi_span(&data, bounds_type{1})
+    constexpr multi_span(reference data) noexcept : multi_span(&data, bounds_type{1})
     {
         static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 ||
                           bounds_type::static_size == 1,
@@ -1308,17 +1286,14 @@ public:
     }
 
     // prevent constructing from temporaries for single-elements
-    constexpr multi_span(value_type&&) = delete;
+    constexpr multi_span(value_type &&) = delete;
 
     // construct from pointer + length
     GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    constexpr multi_span(pointer ptr, size_type size)
-        : multi_span(ptr, bounds_type{size})
-    {}
+    constexpr multi_span(pointer ptr, size_type size) : multi_span(ptr, bounds_type{size}) {}
 
     // construct from pointer + length - multidimensional
-    constexpr multi_span(pointer data, bounds_type bounds)
-        : data_(data), bounds_(std::move(bounds))
+    constexpr multi_span(pointer data, bounds_type bounds) : data_(data), bounds_(std::move(bounds))
     {
         Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0);
     }
@@ -1336,7 +1311,7 @@ public:
 
     // construct from n-dimensions static array
     template <typename T, std::size_t N, typename Helper = details::SpanArrayTraits<T, N>>
-    constexpr multi_span(T (&arr)[N])
+    constexpr multi_span(T(&arr)[N])
         : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}})
     {
         static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
@@ -1357,7 +1332,7 @@ public:
 
     // construct from std::array
     template <typename T, std::size_t N>
-    constexpr multi_span(std::array<T, N>& arr)
+    constexpr multi_span(std::array<T, N> & arr)
         : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
     {
         static_assert(
@@ -1381,7 +1356,7 @@ public:
 
     // prevent constructing from temporary std::array
     template <typename T, std::size_t N>
-    constexpr multi_span(std::array<T, N>&& arr) = delete;
+    constexpr multi_span(std::array<T, N> && arr) = delete;
 
     // construct from containers
     // future: could use contiguous_iterator_traits to identify only contiguous containers
@@ -1389,11 +1364,11 @@ public:
     template <typename Cont, typename DataType = typename Cont::value_type,
               typename = std::enable_if_t<
                   !details::is_multi_span<Cont>::value &&
-                  std::is_convertible<DataType (*)[], value_type (*)[]>::value &&
+                  std::is_convertible<DataType(*)[], value_type(*)[]>::value &&
                   std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                      *std::declval<Cont>().data())>,
                                DataType>::value>>
-    constexpr multi_span(Cont& cont)
+    constexpr multi_span(Cont & cont)
         : multi_span(static_cast<pointer>(cont.data()),
                      details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size())))
     {}
@@ -1402,11 +1377,11 @@ public:
     template <typename Cont, typename DataType = typename Cont::value_type,
               typename = std::enable_if_t<
                   !details::is_multi_span<Cont>::value &&
-                  std::is_convertible<DataType (*)[], value_type (*)[]>::value &&
+                  std::is_convertible<DataType(*)[], value_type(*)[]>::value &&
                   std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                      *std::declval<Cont>().data())>,
                                DataType>::value>>
-    explicit constexpr multi_span(Cont&& cont) = delete;
+    explicit constexpr multi_span(Cont && cont) = delete;
 
     // construct from a convertible multi_span
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
@@ -1419,7 +1394,7 @@ public:
 
     // trivial copy and move
     constexpr multi_span(const multi_span&) = default;
-    constexpr multi_span(multi_span&&) = default;
+    constexpr multi_span(multi_span &&) = default;
 
     // trivial assignment
     constexpr multi_span& operator=(const multi_span&) = default;
@@ -1493,8 +1468,7 @@ public:
     }
 
     // section - creates a non-contiguous, strided multi_span from a contiguous one
-    constexpr strided_span<ValueType, Rank> section(index_type origin,
-                                                    index_type extents) const
+    constexpr strided_span<ValueType, Rank> section(index_type origin, index_type extents) const
     {
         const size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
         return {&this->operator[](origin), size,
@@ -1636,8 +1610,8 @@ public:
     template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
               typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                        std::remove_cv_t<OtherValueType>>::value>>
-    constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const
-        noexcept
+    constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other)
+        const noexcept
     {
         return (other < *this);
     }
@@ -1673,7 +1647,8 @@ constexpr auto as_multi_span(SpanType s, Dimensions2... dims)
 
 // convert a multi_span<T> to a multi_span<const byte>
 template <typename U, std::ptrdiff_t... Dimensions>
-multi_span<const byte, dynamic_range> as_bytes(multi_span<U, Dimensions...> s) noexcept
+multi_span<const byte, dynamic_range>
+as_bytes(multi_span<U, Dimensions...> s) noexcept
 {
     static_assert(std::is_trivial<std::decay_t<U>>::value,
                   "The value_type of multi_span must be a trivial type.");
@@ -1759,7 +1734,8 @@ constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) ->
 }
 
 template <typename T, std::size_t N>
-constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type
+constexpr auto as_multi_span(T (&arr)[N]) ->
+    typename details::SpanArrayTraits<T, N>::type
 {
     return {arr};
 }
@@ -1812,7 +1788,7 @@ constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
 // strided_span is an extension that is not strictly part of the GSL at this time.
 // It is kept here while the multidimensional interface is still being defined.
 template <typename ValueType, std::size_t Rank>
-class strided_span
+class [[deprecated("gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span
 {
 public:
     using bounds_type = strided_bounds<Rank>;
@@ -1886,6 +1862,8 @@ public:
         auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type));
 
         const size_type size = this->bounds().total_size() / d;
+
+        GSL_SUPPRESS(type.3) // NO-FORMAT: attribute
         return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())),
                 size,
                 bounds_type{resize_extent(this->bounds().index_bounds(), d),
@@ -2053,8 +2031,7 @@ private:
 };
 
 template <class Span>
-class contiguous_span_iterator
-{
+class [[deprecated]] contiguous_span_iterator {
 public:
     using iterator_category = std::random_access_iterator_tag;
     using value_type = typename Span::value_type;
@@ -2070,7 +2047,8 @@ private:
     const Span* m_validator;
 
     GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    void validateThis() const {
+    void validateThis() const
+    {
         // iterator is out of range of the array
         Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size());
     }
@@ -2159,7 +2137,7 @@ public:
     bool operator>(const contiguous_span_iterator& rhs) const { return rhs < *this; }
     bool operator>=(const contiguous_span_iterator& rhs) const { return !(rhs > *this); }
 
-    void swap(contiguous_span_iterator& rhs) noexcept
+    void swap(contiguous_span_iterator & rhs) noexcept
     {
         std::swap(data_, rhs.data_);
         std::swap(m_validator, rhs.m_validator);
@@ -2174,7 +2152,7 @@ contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>
 }
 
 template <typename Span>
-class general_span_iterator {
+class [[deprecated]] general_span_iterator {
 public:
     using iterator_category = std::random_access_iterator_tag;
     using value_type = typename Span::value_type;
@@ -2257,7 +2235,7 @@ public:
     bool operator<=(const general_span_iterator& rhs) const { return !(rhs < *this); }
     bool operator>(const general_span_iterator& rhs) const { return rhs < *this; }
     bool operator>=(const general_span_iterator& rhs) const { return !(rhs > *this); }
-    void swap(general_span_iterator& rhs) noexcept
+    void swap(general_span_iterator & rhs) noexcept
     {
         std::swap(m_itr, rhs.m_itr);
         std::swap(m_container, rhs.m_container);
@@ -2273,7 +2251,7 @@ general_span_iterator<Span> operator+(typename general_span_iterator<Span>::diff
 
 } // namespace gsl
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 #if _MSC_VER < 1910
 
 #undef constexpr
@@ -2284,8 +2262,12 @@ general_span_iterator<Span> operator+(typename general_span_iterator<Span>::diff
 
 #endif // _MSC_VER
 
-#if __GNUC__ > 6
+#if defined(__GNUC__) && __GNUC__ > 6
 #pragma GCC diagnostic pop
 #endif // __GNUC__ > 6
 
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
 #endif // GSL_MULTI_SPAN_H

include/gsl/pointers

@@ -25,7 +25,7 @@
 #include <system_error> // for hash
 #include <type_traits>  // for enable_if_t, is_convertible, is_assignable
 
-#if defined(_MSC_VER) && _MSC_VER < 1910
+#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
 #pragma push_macro("constexpr")
 #define constexpr /*constexpr*/
 
@@ -72,13 +72,13 @@ public:
     static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr.");
 
     template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr explicit not_null(U&& u) : ptr_(std::forward<U>(u))
+    constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
     {
         Expects(ptr_ != nullptr);
     }
 
     template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr explicit not_null(T u) : ptr_(u)
+    constexpr not_null(T u) : ptr_(u)
     {
         Expects(ptr_ != nullptr);
     }
@@ -88,7 +88,6 @@ public:
     {
     }
 
-    not_null(not_null&& other) = default;
     not_null(const not_null& other) = default;
     not_null& operator=(const not_null& other) = default;
 
@@ -100,7 +99,7 @@ public:
 
     constexpr operator T() const { return get(); }
     constexpr T operator->() const { return get(); }
-    constexpr decltype(auto) operator*() const { return *get(); } 
+    constexpr decltype(auto) operator*() const { return *get(); }
 
     // prevents compilation when someone attempts to assign a null pointer constant
     not_null(std::nullptr_t) = delete;
@@ -121,7 +120,7 @@ private:
 
 template <class T>
 auto make_not_null(T&& t) {
-    return gsl::not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
+    return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
 }
 
 template <class T>
@@ -189,10 +188,114 @@ struct hash<gsl::not_null<T>>
 
 } // namespace std
 
-#if defined(_MSC_VER) && _MSC_VER < 1910
+namespace gsl
+{
+
+//
+// strict_not_null
+//
+// Restricts a pointer or smart pointer to only hold non-null values,
+//
+// - provides a strict (i.e. explicit constructor from T) wrapper of not_null
+// - to be used for new code that wishes the design to be cleaner and make not_null
+//   checks intentional, or in old code that would like to make the transition.
+//
+//   To make the transition from not_null, incrementally replace not_null
+//   by strict_not_null and fix compilation errors
+//
+//   Expect to
+//   - remove all unneeded conversions from raw pointer to not_null and back
+//   - make API clear by specifying not_null in parameters where needed
+//   - remove unnecessary asserts
+//
+template <class T>
+class strict_not_null: public not_null<T>
+{
+public:
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr explicit strict_not_null(U&& u) :
+        not_null<T>(std::forward<U>(u))
+    {}
+
+    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+    constexpr explicit strict_not_null(T u) :
+        not_null<T>(u)
+    {}
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr strict_not_null(const not_null<U>& other) :
+        not_null<T>(other)
+    {}
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr strict_not_null(const strict_not_null<U>& other) :
+        not_null<T>(other)
+    {}
+
+    strict_not_null(strict_not_null&& other) = default;
+    strict_not_null(const strict_not_null& other) = default;
+    strict_not_null& operator=(const strict_not_null& other) = default;
+    strict_not_null& operator=(const not_null<T>& other)
+    {
+        not_null<T>::operator=(other);
+        return *this;
+    }
+
+    // prevents compilation when someone attempts to assign a null pointer constant
+    strict_not_null(std::nullptr_t) = delete;
+    strict_not_null& operator=(std::nullptr_t) = delete;
+
+    // unwanted operators...pointers only point to single objects!
+    strict_not_null& operator++() = delete;
+    strict_not_null& operator--() = delete;
+    strict_not_null operator++(int) = delete;
+    strict_not_null operator--(int) = delete;
+    strict_not_null& operator+=(std::ptrdiff_t) = delete;
+    strict_not_null& operator-=(std::ptrdiff_t) = delete;
+    void operator[](std::ptrdiff_t) const = delete;
+};
+
+// more unwanted operators
+template <class T, class U>
+std::ptrdiff_t operator-(const strict_not_null<T>&, const strict_not_null<U>&) = delete;
+template <class T>
+strict_not_null<T> operator-(const strict_not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+strict_not_null<T> operator+(const strict_not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete;
+
+template <class T>
+auto make_strict_not_null(T&& t) {
+    return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
+}
+
+#if ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
+
+// deduction guides to prevent the ctad-maybe-unsupported warning
+template <class T> not_null(T) -> not_null<T>;
+template <class T> strict_not_null(T) -> strict_not_null<T>;
+
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
+
+} // namespace gsl
+
+namespace std
+{
+template <class T>
+struct hash<gsl::strict_not_null<T>>
+{
+    std::size_t operator()(const gsl::strict_not_null<T>& value) const { return hash<T>{}(value); }
+};
+
+} // namespace std
+
+#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
+
 #undef constexpr
 #pragma pop_macro("constexpr")
 
-#endif // defined(_MSC_VER) && _MSC_VER < 1910
+#endif // defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
 
 #endif // GSL_POINTERS_H

include/gsl/span_ext

@@ -0,0 +1,198 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_SPAN_EXT_H
+#define GSL_SPAN_EXT_H
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// File: span_ext
+// Purpose: continue offering features that have been cut from the official
+//   implementation of span.
+//   While modernizing gsl::span a number of features needed to be removed to
+//   be compliant with the design of std::span
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include <gsl/gsl_util> // for narrow_cast, narrow
+#include <gsl/span>     // for span
+
+#include <algorithm> // for lexicographical_compare
+#include <cstddef>   // for ptrdiff_t, size_t
+#include <utility>
+
+namespace gsl
+{
+
+// [span.comparison], span comparison operators
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r)
+{
+    return std::equal(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator!=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l == r);
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l > r);
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return r < l;
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l < r);
+}
+
+//
+// make_span() - Utility functions for creating spans
+//
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count)
+{
+    return span<ElementType>(ptr, count);
+}
+
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
+{
+    return span<ElementType>(firstElem, lastElem);
+}
+
+template <class ElementType, std::size_t N>
+constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept
+{
+    return span<ElementType, N>(arr);
+}
+
+template <class Container>
+constexpr span<typename Container::value_type> make_span(Container& cont)
+{
+    return span<typename Container::value_type>(cont);
+}
+
+template <class Container>
+constexpr span<const typename Container::value_type> make_span(const Container& cont)
+{
+    return span<const typename Container::value_type>(cont);
+}
+
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count)
+{
+    return span<typename Ptr::element_type>(cont, count);
+}
+
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
+{
+    return span<typename Ptr::element_type>(cont);
+}
+
+// Specialization of gsl::at for span
+template <class ElementType, std::size_t Extent>
+constexpr ElementType& at(span<ElementType, Extent> s, index i)
+{
+    // No bounds checking here because it is done in span::operator[] called below
+    Ensures(i >= 0);
+    return s[narrow_cast<std::size_t>(i)];
+}
+
+// [span.obs] Free observer functions
+template <class ElementType, std::size_t Extent>
+constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept
+{
+    return static_cast<std::ptrdiff_t>(s.size());
+}
+
+// [span.iter] Free functions for begin/end functions
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+begin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.begin();
+}
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+end(const span<ElementType, Extent>& s) noexcept
+{
+    return s.end();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rbegin();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rend();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+cbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.begin();
+}
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+cend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.end();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rbegin();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rend();
+}
+
+} // namespace gsl
+
+#endif // GSL_SPAN_EXT_H

samples/gsl_transition

@@ -1,130 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_TRANSITION_H
-#define GSL_TRANSITION_H
-
-#include <gsl/gsl_assert>  // for Ensures, Expects
-#include <gsl/pointers> // for gsl::not_null
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif                          // defined(_MSC_VER) && _MSC_VER < 1910
-
-namespace gsl_helpers
-{
-//
-// sloppy_not_null
-//
-// Restricts a pointer or smart pointer to only hold non-null values,
-// 
-// - provides a sloppy (i.e. no explicit contructor from T) wrapper of gsl::not_null
-// - is temporary, only to be used to incrementally transition of code 
-//   using older version of gsl::not_null to the new one that made the constructor explicit
-// 
-// To make the transition:
-//
-// - replace all occurences of gsl::not_null in your code by sloppy_not_null
-//   variant: rename gsl::not_null by NotNull by including the following in your code,
-//   foe example, in a common include file:
-//
-//   template<typename T>
-//   using NotNull = gsl::not_null<T>;
-//
-//   compile using old version of GSL
-//   change GSL version and replace gsl::not_null by gsl_helpers::sloppy_not_null
-//   in the added code lines above
-// 
-// - compile - compilation should be successful
-// - replace some sloppy_not_nulls by gsl::not_null, fix compilation erros, 
-//   redesign as needed, compile and test
-// - repeat until no sloppy_not_nulls remain
-//
-template <class T>
-class sloppy_not_null: public gsl::not_null<T>
-{
-public:
-
-    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr sloppy_not_null(U&& u) :
-        gsl::not_null<T>(std::forward<U>(u))
-    {}
-
-    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr sloppy_not_null(T u) :
-        gsl::not_null<T>(u)
-    {}
-
-    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr sloppy_not_null(const gsl::not_null<U>& other) :
-        gsl::not_null<T>(other)
-    {}
-
-    sloppy_not_null(sloppy_not_null&& other) = default;
-    sloppy_not_null(const sloppy_not_null& other) = default;
-    sloppy_not_null& operator=(const sloppy_not_null& other) = default;
-    sloppy_not_null& operator=(const gsl::not_null<T>& other)
-    {
-        gsl::not_null<T>::operator=(other);
-        return *this;
-    }
-
-    // prevents compilation when someone attempts to assign a null pointer constant
-    sloppy_not_null(std::nullptr_t) = delete;
-    sloppy_not_null& operator=(std::nullptr_t) = delete;
-
-    // unwanted operators...pointers only point to single objects!
-    sloppy_not_null& operator++() = delete;
-    sloppy_not_null& operator--() = delete;
-    sloppy_not_null operator++(int) = delete;
-    sloppy_not_null operator--(int) = delete;
-    sloppy_not_null& operator+=(std::ptrdiff_t) = delete;
-    sloppy_not_null& operator-=(std::ptrdiff_t) = delete;
-    void operator[](std::ptrdiff_t) const = delete;
-};
-
-// more unwanted operators
-template <class T, class U>
-std::ptrdiff_t operator-(const sloppy_not_null<T>&, const sloppy_not_null<U>&) = delete;
-template <class T>
-sloppy_not_null<T> operator-(const sloppy_not_null<T>&, std::ptrdiff_t) = delete;
-template <class T>
-sloppy_not_null<T> operator+(const sloppy_not_null<T>&, std::ptrdiff_t) = delete;
-template <class T>
-sloppy_not_null<T> operator+(std::ptrdiff_t, const sloppy_not_null<T>&) = delete;
-
-} // namespace gsl
-
-namespace std
-{
-template <class T>
-struct hash<gsl_helpers::sloppy_not_null<T>>
-{
-    std::size_t operator()(const gsl_helpers::sloppy_not_null<T>& value) const { return hash<T>{}(value); }
-};
-
-} // namespace std
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // defined(_MSC_VER) && _MSC_VER < 1910
-
-#endif // GSL_TRANSITION_H
-

tests/CMakeLists.txt

@@ -1,31 +1,37 @@
-cmake_minimum_required(VERSION 2.8.7)
+cmake_minimum_required(VERSION 3.0.2)
 
 project(GSLTests CXX)
 
 # will make visual studio generated project group files
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-list(APPEND CATCH_CMAKE_ARGS
-    "-DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/external"
-    "-DNO_SELFTEST=true"
+configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
+execute_process(
+    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+    RESULT_VARIABLE result
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
 )
-
-if(GIT_FOUND)
-    # add catch
-    ExternalProject_Add(
-        catch
-        PREFIX ${CMAKE_BINARY_DIR}/catch
-        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-        GIT_TAG v2.0.1
-        CMAKE_ARGS ${CATCH_CMAKE_ARGS}
-        LOG_DOWNLOAD 1
-        UPDATE_DISCONNECTED 1
-    )
-else()
-    # assume catch is installed in a system directory
-    add_custom_target(catch)
+if(result)
+    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
 endif()
 
+execute_process(
+    COMMAND ${CMAKE_COMMAND} --build .
+    RESULT_VARIABLE result
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+)
+if(result)
+    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+endif()
+
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+
+add_subdirectory(
+    ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
+    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
+    EXCLUDE_FROM_ALL
+)
+
 if (MSVC AND (GSL_CXX_STANDARD EQUAL 17))
     set(GSL_CPLUSPLUS_OPT -Zc:__cplusplus -permissive-)
 endif()
@@ -33,14 +39,48 @@ endif()
 # this interface adds compile options to how the tests are run
 # please try to keep entries ordered =)
 add_library(gsl_tests_config INTERFACE)
-target_compile_options(gsl_tests_config INTERFACE
-    $<$<CXX_COMPILER_ID:MSVC>:
+if(MSVC) # MSVC or simulating MSVC
+    target_compile_options(gsl_tests_config INTERFACE
+        ${GSL_CPLUSPLUS_OPT}
         /EHsc
         /W4
         /WX
-    >
-    ${GSL_CPLUSPLUS_OPT}
-    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:
+        $<$<CXX_COMPILER_ID:MSVC>:
+          /wd4996  # Use of function or classes marked [[deprecated]]
+          /wd26409 # CppCoreCheck - GTest
+          /wd26426 # CppCoreCheck - GTest
+          /wd26440 # CppCoreCheck - GTest
+          /wd26446 # CppCoreCheck - prefer gsl::at()
+          /wd26472 # CppCoreCheck - use gsl::narrow(_cast)
+          /wd26481 # CppCoreCheck - use span instead of pointer arithmetic
+          $<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,1920>: # VS2015
+            /wd4189 # variable is initialized but not referenced
+            $<$<NOT:$<CONFIG:Debug>>: # Release, RelWithDebInfo
+              /wd4702 # Unreachable code
+            >
+          >
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-covered-switch-default # GTest
+          -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
+          -Wno-global-constructors # GTest
+          -Wno-language-extension-token # GTest gtest-port.h
+          -Wno-missing-braces
+          -Wno-missing-prototypes
+          -Wno-shift-sign-overflow # GTest gtest-port.h
+          -Wno-undef # GTest
+          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+            -Wno-unused-member-function
+            -Wno-unused-variable
+          >
+        >
+    )
+else()
+    target_compile_options(gsl_tests_config INTERFACE
         -fno-strict-aliasing
         -Wall
         -Wcast-align
@@ -48,54 +88,80 @@ target_compile_options(gsl_tests_config INTERFACE
         -Wctor-dtor-privacy
         -Werror
         -Wextra
-        -Wno-missing-braces
-        -Wno-unknown-attributes
-        -Wnon-virtual-dtor
-        -Wold-style-cast
-        -Woverloaded-virtual
         -Wpedantic
         -Wshadow
         -Wsign-conversion
-    >
+        -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-braces
+          -Wno-covered-switch-default # GTest
+          -Wno-global-constructors # GTest
+          -Wno-missing-prototypes
+          -Wno-padded
+          -Wno-unknown-attributes
+          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
+          -Wno-weak-vtables
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+            -Wno-unused-member-function
+            -Wno-unused-variable
+          >
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.99>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
+          >
+        >
+        $<$<CXX_COMPILER_ID:AppleClang>:
+          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,9.1>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,10>>:
+            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
+          >
+        >
+        $<$<CXX_COMPILER_ID:GNU>:
+          -Wdouble-promotion # float implicit to double
+          -Wlogical-op # suspicious uses of logical operators
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            -Wduplicated-cond # duplicated if-else conditions
+            -Wmisleading-indentation
+            -Wnull-dereference
+            $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+              -Wno-unused-variable
+            >
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
+            -Wduplicated-branches # identical if-else branches
+          >
+        >
+    )
+endif(MSVC)
+
+# for tests to find the gtest header
+target_include_directories(gsl_tests_config SYSTEM INTERFACE
+    googletest/googletest/include
 )
 
-# for tests to find the catch header
-target_include_directories(gsl_tests_config INTERFACE
-    ${CMAKE_BINARY_DIR}/external/include
-)
-
-# 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")
+set_property(TARGET  PROPERTY FOLDER "GSL_tests")
 
 function(add_gsl_test name)
     add_executable(${name} ${name}.cpp)
     target_link_libraries(${name}
         GSL
-        test_catch
         gsl_tests_config
+        gtest_main
     )
-    add_dependencies(${name} catch)
     add_test(
-      ${name}
-      ${name}
+        ${name}
+        ${name}
     )
     # group all tests under GSL_tests
     set_property(TARGET ${name} PROPERTY FOLDER "GSL_tests")
 endfunction()
 
 add_gsl_test(span_tests)
+add_gsl_test(span_ext_tests)
+add_gsl_test(span_compatibility_tests)
 add_gsl_test(multi_span_tests)
 add_gsl_test(strided_span_tests)
 add_gsl_test(string_span_tests)
@@ -107,7 +173,7 @@ add_gsl_test(utils_tests)
 add_gsl_test(owner_tests)
 add_gsl_test(byte_tests)
 add_gsl_test(algorithm_tests)
-add_gsl_test(sloppy_notnull_tests)
+add_gsl_test(strict_notnull_tests)
 
 
 # No exception tests
@@ -121,45 +187,74 @@ endforeach(flag_var)
 # this interface adds compile options to how the tests are run
 # please try to keep entries ordered =)
 add_library(gsl_tests_config_noexcept INTERFACE)
-target_compile_options(gsl_tests_config_noexcept INTERFACE
-    $<$<CXX_COMPILER_ID:MSVC>:
-        /D_HAS_EXCEPTIONS=0
-        /wd4702
-        /wd4577
+if(MSVC) # MSVC or simulating MSVC
+    target_compile_definitions(gsl_tests_config_noexcept INTERFACE
+        _HAS_EXCEPTIONS=0 # disable exceptions in the Microsoft STL
+    )
+    target_compile_options(gsl_tests_config_noexcept INTERFACE
+        ${GSL_CPLUSPLUS_OPT}
         /W4
         /WX
-    >
-    ${GSL_CPLUSPLUS_OPT}
-    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:
-        -fno-strict-aliasing
+        $<$<CXX_COMPILER_ID:MSVC>:
+          /wd4577
+          /wd4702
+          /wd26440 # CppCoreCheck - GTest
+          /wd26446 # CppCoreCheck - prefer gsl::at()
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-prototypes
+          -Wno-unknown-attributes
+        >
+    )
+else()
+    target_compile_options(gsl_tests_config_noexcept INTERFACE
         -fno-exceptions
+        -fno-strict-aliasing
         -Wall
         -Wcast-align
         -Wconversion
         -Wctor-dtor-privacy
         -Werror
         -Wextra
-        -Wno-missing-braces
-        -Wno-unknown-attributes
-        -Wnon-virtual-dtor
-        -Wold-style-cast
-        -Woverloaded-virtual
         -Wpedantic
         -Wshadow
         -Wsign-conversion
-    >
-)
-
-# set definitions for tests
-target_compile_definitions(gsl_tests_config_noexcept INTERFACE
-    GSL_TERMINATE_ON_CONTRACT_VIOLATION
-)
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-prototypes
+          -Wno-unknown-attributes
+          -Wno-weak-vtables
+        >
+        $<$<CXX_COMPILER_ID:GNU>:
+          -Wdouble-promotion # float implicit to double
+          -Wlogical-op # suspicious uses of logical operators
+          -Wuseless-cast # casting to its own type
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            -Wduplicated-cond # duplicated if-else conditions
+            -Wmisleading-indentation
+            -Wnull-dereference
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
+            -Wduplicated-branches # identical if-else branches
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,8>>:
+            -Wcast-align=strict # increase alignment (i.e. char* to int*)
+          >
+        >
+    )
+endif(MSVC)
 
 function(add_gsl_test_noexcept name)
     add_executable(${name} ${name}.cpp)
     target_link_libraries(${name}
         GSL
         gsl_tests_config_noexcept
+        gtest_main
     )
     add_test(
       ${name}
@@ -169,5 +264,4 @@ function(add_gsl_test_noexcept name)
     set_property(TARGET ${name} PROPERTY FOLDER "GSL_tests_noexcept")
 endfunction()
 
-add_gsl_test_noexcept(no_exception_throw_tests)
 add_gsl_test_noexcept(no_exception_ensure_tests)

tests/CMakeLists.txt.in

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(googletest-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(googletest
+  GIT_REPOSITORY    https://github.com/google/googletest.git
+  GIT_TAG           703bd9caab50b139428cea1aaff9974ebee5742e
+  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
+  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND     ""
+  INSTALL_COMMAND   ""
+  TEST_COMMAND      ""
+)

tests/algorithm_tests.cpp

@@ -14,30 +14,26 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHE...
-
+#include <gtest/gtest.h>
 #include <gsl/gsl_algorithm> // for copy
 #include <gsl/span>          // for span
-
 #include <array>   // for array
 #include <cstddef> // for size_t
 
-namespace gsl {
+namespace
+{
+    static constexpr char deathstring[] = "Expected Death";
+}
+
+namespace gsl
+{
 struct fail_fast;
-}  // namespace gsl
+} // namespace gsl
 
 using namespace std;
 using namespace gsl;
 
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("same_type")
+TEST(algorithm_tests, same_type)
 {
     // dynamic source and destination span
     {
@@ -50,9 +46,10 @@ TEST_CASE("same_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 
@@ -67,9 +64,10 @@ TEST_CASE("same_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 
@@ -84,9 +82,10 @@ TEST_CASE("same_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 
@@ -101,17 +100,15 @@ TEST_CASE("same_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 }
 
-
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("compatible_type")
+TEST(algorithm_tests, compatible_type)
 {
     // dynamic source and destination span
     {
@@ -124,9 +121,10 @@ TEST_CASE("compatible_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 
@@ -141,9 +139,10 @@ TEST_CASE("compatible_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 
@@ -158,9 +157,10 @@ TEST_CASE("compatible_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 
@@ -175,15 +175,16 @@ TEST_CASE("compatible_type")
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
 
-        for (std::size_t i = 0; i < src.size(); ++i) {
-            CHECK(dst[i] == src[i]);
-            CHECK(dst[i + src.size()] == src[i]);
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
         }
     }
 }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
-TEST_CASE("incompatible_type")
+TEST(algorithm_tests, incompatible_type)
 {
     std::array<int, 4> src{1, 2, 3, 4};
     std::array<int*, 12> dst{};
@@ -201,8 +202,13 @@ TEST_CASE("incompatible_type")
 }
 #endif
 
-TEST_CASE("small_destination_span")
+TEST(algorithm_tests, small_destination_span)
 {
+    std::set_terminate([] {
+        std::cerr << "Expected Death. small_destination_span";
+        std::abort();
+    });
+
     std::array<int, 12> src{1, 2, 3, 4};
     std::array<int, 4> dst{};
 
@@ -211,9 +217,9 @@ TEST_CASE("small_destination_span")
     const span<int> dst_span_dyn(dst);
     const span<int, 4> dst_span_static(dst);
 
-    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);
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_dyn), deathstring);
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_static), deathstring);
+    EXPECT_DEATH(copy(src_span_static, dst_span_dyn), deathstring);
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     copy(src_span_static, dst_span_static);

tests/assertion_tests.cpp

@@ -14,39 +14,48 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHECK...
-
+#include <gtest/gtest.h>
 #include <gsl/gsl_assert> // for fail_fast (ptr only), Ensures, Expects
 
 using namespace gsl;
 
+namespace
+{
+static constexpr char deathstring[] = "Expected Death";
+
 int f(int i)
 {
     Expects(i > 0 && i < 10);
     return i;
 }
 
-TEST_CASE("expects")
-{
-    CHECK(f(2) == 2);
-    CHECK_THROWS_AS(f(10), fail_fast);
-}
-
 int g(int i)
 {
     i++;
     Ensures(i > 0 && i < 10);
     return i;
 }
+} // namespace
 
-TEST_CASE("ensures")
+TEST(assertion_tests, expects)
 {
-    CHECK(g(2) == 3);
-    CHECK_THROWS_AS(g(9), fail_fast);
+    std::set_terminate([] {
+        std::cerr << "Expected Death. expects";
+        std::abort();
+    });
+
+    EXPECT_TRUE(f(2) == 2);
+    EXPECT_DEATH(f(10), deathstring);
+}
+
+
+TEST(assertion_tests, ensures)
+{
+    std::set_terminate([] {
+        std::cerr << "Expected Death. ensures";
+        std::abort();
+    });
+
+    EXPECT_TRUE(g(2) == 3);
+    EXPECT_DEATH(g(9), deathstring);
 }

tests/at_tests.cpp

@@ -14,13 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK_THROW...
+#include <gtest/gtest.h>
 
 #include <gsl/gsl_util> // for at
 
@@ -29,88 +23,95 @@
 #include <initializer_list> // for initializer_list
 #include <vector>           // for vector
 
+namespace
+{
+    static constexpr char deathstring[] = "Expected Death";
+}
 
-namespace gsl {
-struct fail_fast;
-}  // namespace gsl
-
-using gsl::fail_fast;
-
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("static_array")
+TEST(at_tests, static_array)
 {
     int a[4] = {1, 2, 3, 4};
     const int(&c_a)[4] = a;
 
     for (int i = 0; i < 4; ++i) {
-        CHECK(&gsl::at(a, i) == &a[i]);
-        CHECK(&gsl::at(c_a, i) == &a[i]);
+        EXPECT_TRUE(&gsl::at(a, i) == &a[i]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[i]);
     }
 
-    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);
+    std::set_terminate([] {
+        std::cerr << "Expected Death. static_array";
+        std::abort();
+    });
+
+    EXPECT_DEATH(gsl::at(a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(a, 4), deathstring);
+    EXPECT_DEATH(gsl::at(c_a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(c_a, 4), deathstring);
 }
 
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("std_array")
+TEST(at_tests, std_array)
 {
     std::array<int, 4> a = {1, 2, 3, 4};
     const std::array<int, 4>& c_a = a;
 
     for (int i = 0; i < 4; ++i) {
-        CHECK(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
-        CHECK(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
     }
 
-    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);
+    std::set_terminate([] {
+        std::cerr << "Expected Death. std_array";
+        std::abort();
+    });
+
+    EXPECT_DEATH(gsl::at(a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(a, 4), deathstring);
+    EXPECT_DEATH(gsl::at(c_a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(c_a, 4), deathstring);
 }
 
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("StdVector")
+TEST(at_tests, std_vector)
 {
     std::vector<int> a = {1, 2, 3, 4};
     const std::vector<int>& c_a = a;
 
     for (int i = 0; i < 4; ++i) {
-        CHECK(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
-        CHECK(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
     }
 
-    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);
+    std::set_terminate([] {
+        std::cerr << "Expected Death. std_vector";
+        std::abort();
+    });
+
+    EXPECT_DEATH(gsl::at(a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(a, 4), deathstring);
+    EXPECT_DEATH(gsl::at(c_a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(c_a, 4), deathstring);
 }
 
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("InitializerList")
+TEST(at_tests, InitializerList)
 {
     const std::initializer_list<int> a = {1, 2, 3, 4};
 
     for (int i = 0; i < 4; ++i) {
-        CHECK(gsl::at(a, i) == i + 1);
-        CHECK(gsl::at({1, 2, 3, 4}, i) == i + 1);
+        EXPECT_TRUE(gsl::at(a, i) == i + 1);
+        EXPECT_TRUE(gsl::at({1, 2, 3, 4}, i) == i + 1);
     }
 
-    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);
+    std::set_terminate([] {
+        std::cerr << "Expected Death. InitializerList";
+        std::abort();
+    });
+
+    EXPECT_DEATH(gsl::at(a, -1), deathstring);
+    EXPECT_DEATH(gsl::at(a, 4), deathstring);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, -1), deathstring);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, 4), deathstring);
 }
 
 #if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1910
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
 static constexpr bool test_constexpr()
 {
     int a1[4] = {1, 2, 3, 4};
@@ -132,4 +133,3 @@ static constexpr bool test_constexpr()
 
 static_assert(test_constexpr(), "FAIL");
 #endif
-

tests/bounds_tests.cpp

@@ -14,22 +14,12 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, TEST_CASE
+#include <gtest/gtest.h>
 
 #include <gsl/multi_span> // for static_bounds, static_bounds_dynamic_range_t
 
 #include <cstddef> // for ptrdiff_t, size_t
 
-namespace gsl {
-struct fail_fast;
-}  // namespace gsl
-
 using namespace std;
 using namespace gsl;
 
@@ -38,8 +28,7 @@ namespace
 void use(std::ptrdiff_t&) {}
 }
 
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-TEST_CASE("basic_bounds")
+TEST(bounds_tests, basic_bounds)
 {
     for (auto point : static_bounds<dynamic_range, 3, 4>{2}) {
         for (decltype(point)::size_type j = 0;
@@ -51,9 +40,7 @@ TEST_CASE("basic_bounds")
     }
 }
 
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("bounds_basic")
+TEST(bounds_tests, bounds_basic)
 {
     static_bounds<3, 4, 5> b;
     const auto a = b.slice();
@@ -62,9 +49,7 @@ TEST_CASE("bounds_basic")
     x.slice().slice();
 }
 
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("arrayview_iterator")
+TEST(bounds_tests, arrayview_iterator)
 {
     static_bounds<4, dynamic_range, 2> bounds{3};
 
@@ -82,8 +67,7 @@ TEST_CASE("arrayview_iterator")
 #endif
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("bounds_convertible")
+TEST(bounds_tests, bounds_convertible)
 {
     static_bounds<7, 4, 2> b1;
     static_bounds<7, dynamic_range, 2> b2 = b1;
@@ -96,18 +80,21 @@ TEST_CASE("bounds_convertible")
     static_bounds<7, 4, 2> b4 = b3;
     (void) b4;
 
-    static_bounds<dynamic_range> b11;
-
     static_bounds<dynamic_range> b5;
     static_bounds<34> b6;
 
+    std::set_terminate([] {
+        std::cerr << "Expected Death. bounds_convertible";
+        std::abort();
+    });
+
     b5 = static_bounds<20>();
-    CHECK_THROWS_AS(b6 = b5, fail_fast);
+    EXPECT_DEATH(b6 = b5, ".*");
     b5 = static_bounds<34>();
     b6 = b5;
 
-    CHECK(b5 == b6);
-    CHECK(b5.size() == b6.size());
+    EXPECT_TRUE(b5 == b6);
+    EXPECT_TRUE(b5.size() == b6.size());
 }
 
 #ifdef CONFIRM_COMPILATION_ERRORS

tests/byte_tests.cpp

@@ -14,13 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
+#include <gtest/gtest.h>
 
 #include <gsl/gsl_byte> // for to_byte, to_integer, byte, operator&, ope...
 
@@ -29,104 +23,103 @@ using namespace gsl;
 
 namespace
 {
-TEST_CASE("construction")
-{
-    {
-        const byte b = static_cast<byte>(4);
-        CHECK(static_cast<unsigned char>(b) == 4);
-    }
-
-    GSL_SUPPRESS(es.49)
-    {
-        const byte b = byte(12);
-        CHECK(static_cast<unsigned char>(b) == 12);
-    }
-
-    {
-        const byte b = to_byte<12>();
-        CHECK(static_cast<unsigned char>(b) == 12);
-    }
-    {
-        const unsigned char uc = 12;
-        const byte b = to_byte(uc);
-        CHECK(static_cast<unsigned char>(b) == 12);
-    }
-
-#if defined(__cplusplus) && (__cplusplus >= 201703L)
-    {
-        const byte b { 14 };
-        CHECK(static_cast<unsigned char>(b) == 14);
-    }
-#endif
-}
-
-TEST_CASE("bitwise_operations")
-{
-    const byte b = to_byte<0xFF>();
-
-    byte a = to_byte<0x00>();
-    CHECK((b | a) == to_byte<0xFF>());
-    CHECK(a == to_byte<0x00>());
-
-    a |= b;
-    CHECK(a == to_byte<0xFF>());
-
-    a = to_byte<0x01>();
-    CHECK((b & a) == to_byte<0x01>());
-
-    a &= b;
-    CHECK(a == to_byte<0x01>());
-
-    CHECK((b ^ a) == to_byte<0xFE>());
-
-    CHECK(a == to_byte<0x01>());
-    a ^= b;
-    CHECK(a == to_byte<0xFE>());
-
-    a = to_byte<0x01>();
-    CHECK(~a == to_byte<0xFE>());
-
-    a = to_byte<0xFF>();
-    CHECK((a << 4) == to_byte<0xF0>());
-    CHECK((a >> 4) == to_byte<0x0F>());
-
-    a <<= 4;
-    CHECK(a == to_byte<0xF0>());
-    a >>= 4;
-    CHECK(a == to_byte<0x0F>());
-}
-
-TEST_CASE("to_integer")
-{
-    const byte b = to_byte<0x12>();
-
-    CHECK(0x12 == gsl::to_integer<char>(b));
-    CHECK(0x12 == gsl::to_integer<short>(b));
-    CHECK(0x12 == gsl::to_integer<long>(b));
-    CHECK(0x12 == gsl::to_integer<long long>(b));
-
-    CHECK(0x12 == gsl::to_integer<unsigned char>(b));
-    CHECK(0x12 == gsl::to_integer<unsigned short>(b));
-    CHECK(0x12 == gsl::to_integer<unsigned long>(b));
-    CHECK(0x12 == gsl::to_integer<unsigned long long>(b));
-
-    //      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;
 }
 
-GSL_SUPPRESS(type.1)
-TEST_CASE("aliasing")
+TEST(byte_tests, construction)
+{
+    {
+        const byte b = static_cast<byte>(4);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
+    }
+
+    GSL_SUPPRESS(es.49)
+    {
+        const byte b = byte(12);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+
+    {
+        const byte b = to_byte<12>();
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+    {
+        const unsigned char uc = 12;
+        const byte b = to_byte(uc);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+    {
+        const byte b { 14 };
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
+    }
+#endif
+}
+
+TEST(byte_tests, bitwise_operations)
+{
+    const byte b = to_byte<0xFF>();
+
+    byte a = to_byte<0x00>();
+    EXPECT_TRUE((b | a) == to_byte<0xFF>());
+    EXPECT_TRUE(a == to_byte<0x00>());
+
+    a |= b;
+    EXPECT_TRUE(a == to_byte<0xFF>());
+
+    a = to_byte<0x01>();
+    EXPECT_TRUE((b & a) == to_byte<0x01>());
+
+    a &= b;
+    EXPECT_TRUE(a == to_byte<0x01>());
+
+    EXPECT_TRUE((b ^ a) == to_byte<0xFE>());
+
+    EXPECT_TRUE(a == to_byte<0x01>());
+    a ^= b;
+    EXPECT_TRUE(a == to_byte<0xFE>());
+
+    a = to_byte<0x01>();
+    EXPECT_TRUE(~a == to_byte<0xFE>());
+
+    a = to_byte<0xFF>();
+    EXPECT_TRUE((a << 4) == to_byte<0xF0>());
+    EXPECT_TRUE((a >> 4) == to_byte<0x0F>());
+
+    a <<= 4;
+    EXPECT_TRUE(a == to_byte<0xF0>());
+    a >>= 4;
+    EXPECT_TRUE(a == to_byte<0x0F>());
+}
+
+TEST(byte_tests, to_integer)
+{
+    const byte b = to_byte<0x12>();
+
+    EXPECT_TRUE(0x12 == gsl::to_integer<char>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<short>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<long>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<long long>(b));
+
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned char>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned short>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long long>(b));
+
+    //      EXPECT_TRUE(0x12 == gsl::to_integer<float>(b));   // expect compile-time error
+    //      EXPECT_TRUE(0x12 == gsl::to_integer<double>(b));  // expect compile-time error
+}
+
+TEST(byte_tests, aliasing)
 {
     int i{0};
     const int res = modify_both(reinterpret_cast<byte&>(i), i);
-    CHECK(res == i);
+    EXPECT_TRUE(res == i);
 }
 
 }

tests/no_exception_ensure_tests.cpp

@@ -14,25 +14,21 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <cstdlib>      // for std::exit
-#include <gsl/span>     // for span
+#include <cstdlib>  // for std::exit
+#include <gsl/span> // for span
 
 int operator_subscript_no_throw() noexcept
 {
-    int arr[10]; 
-    const gsl::span<int> sp { arr };
+    int arr[10];
+    const gsl::span<int> sp{arr};
     return sp[11];
 }
 
-
-void test_terminate()
-{ 
-    std::exit(0);
-}
+[[noreturn]] void test_terminate() { std::exit(0); }
 
 void setup_termination_handler() noexcept
 {
-#if defined(_MSC_VER)
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
 
     auto& handler = gsl::details::get_terminate_handler();
     handler = &test_terminate;
@@ -44,7 +40,6 @@ void setup_termination_handler() noexcept
 #endif
 }
 
-
 int main() noexcept
 {
     setup_termination_handler();

tests/no_exception_throw_tests.cpp

@@ -1,52 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include <cstdlib>      // for std::exit
-#include <gsl/gsl_util> // for narrow
-#include <gsl/gsl_assert> // for get_terminate
-
-int narrow_no_throw()
-{
-    const long long bigNumber = 0x0fffffffffffffff;
-    return gsl::narrow<int>(bigNumber); 
-}
-
-void test_terminate()
-{ 
-    std::exit(0);
-}
-
-void setup_termination_handler() noexcept
-{
-#if defined(_MSC_VER)
-
-    auto& handler = gsl::details::get_terminate_handler();
-    handler = &test_terminate;
-
-#else
-
-    std::set_terminate(test_terminate);
-
-#endif
-}
-
-
-int main()
-{
-    setup_termination_handler();
-    narrow_no_throw();
-    return -1;
-}

tests/notnull_tests.cpp

@@ -14,18 +14,9 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
+#include <gtest/gtest.h>
 
-// Fix VS2015 build breaks in Release
-#pragma warning(disable : 4702) // unreachable code
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
-
-#include <gsl/pointers>       // for not_null, operator<, operator<=, operator>
+#include <gsl/pointers> // for not_null, operator<, operator<=, operator>
 
 #include <algorithm> // for addressof
 #include <memory>    // for shared_ptr, make_shared, operator<, opera...
@@ -34,13 +25,13 @@
 #include <string>    // for basic_string, operator==, string, operator<<
 #include <typeinfo>  // for type_info
 
-namespace gsl
-{
-struct fail_fast;
-} // namespace gsl
-
 using namespace gsl;
 
+namespace
+{
+static constexpr char deathstring[] = "Expected Death";
+} //namespace
+
 struct MyBase
 {
 };
@@ -128,81 +119,138 @@ struct NonCopyableNonMovable
 };
 
 GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-bool helper(not_null<int*> p)
-{
-    return *p == 12;
-}
-
+bool helper(not_null<int*> p) { return *p == 12; }
 GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-bool helper_const(not_null<const int*> p)
-{
-    return *p == 12;
-}
+bool helper_const(not_null<const int*> p) { return *p == 12; }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("TestNotNullConstructors")
+int* return_pointer() { return nullptr; }
+
+TEST(notnull_tests, 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!
-    not_null<int*> p;                   // yay...does not compile!
-    std::unique_ptr<int> up = std::make_unique<int>(120);
-    not_null<int*> p = up;
+        not_null<int*> p = nullptr;          // yay...does not compile!
+        not_null<std::vector<char>*> p1 = 0; // yay...does not compile!
+        not_null<int*> p2;                   // yay...does not compile!
+        std::unique_ptr<int> up = std::make_unique<int>(120);
+        not_null<int*> p3 = up;
 
-    // Forbid non-nullptr assignable types
-    not_null<std::vector<int>> f(std::vector<int>{1});
-    not_null<int> z(10);
-    not_null<std::vector<int>> y({1, 2});
+        // Forbid non-nullptr assignable types
+        not_null<std::vector<int>> f(std::vector<int>{1});
+        not_null<int> z(10);
+        not_null<std::vector<int>> y({1, 2});
 #endif
-    int i = 12;
-    auto rp = RefCounted<int>(&i);
-    not_null<int*> p(rp);
-    CHECK(p.get() == &i);
+    }
 
-    not_null<std::shared_ptr<int>> x(
-        std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
+    std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullConstructors";
+        std::abort();
+    });
+    {
+        // from shared pointer
+        int i = 12;
+        auto rp = RefCounted<int>(&i);
+        not_null<int*> p(rp);
+        EXPECT_TRUE(p.get() == &i);
 
-#ifdef GSL_THROW_ON_CONTRACT_VIOLATION
-    int* pi = nullptr;
-    CHECK_THROWS_AS(not_null<decltype(pi)>(pi), fail_fast);
-#endif
+        not_null<std::shared_ptr<int>> x(
+            std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
+
+        int* pi = nullptr;
+        EXPECT_DEATH((not_null<decltype(pi)>(pi)), deathstring);
+    }
+
+    {
+        // from pointer to local
+        int t = 42;
+
+        not_null<int*> x = &t;
+        helper(&t);
+        helper_const(&t);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from raw pointer
+        // from not_null pointer
+
+        int t = 42;
+        int* p = &t;
+
+        not_null<int*> x = p;
+        helper(p);
+        helper_const(p);
+        helper(x);
+        helper_const(x);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from raw const pointer
+        // from not_null const pointer
+
+        int t = 42;
+        const int* cp = &t;
+
+        not_null<const int*> x = cp;
+        helper_const(cp);
+        helper_const(x);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from not_null const pointer, using auto
+        int t = 42;
+        const int* cp = &t;
+
+        auto x = not_null<const int*>{cp};
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from returned pointer
+
+        EXPECT_DEATH(helper(return_pointer()), deathstring);
+        EXPECT_DEATH(helper_const(return_pointer()), deathstring);
+    }
 }
 
-template<typename T>
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
+template <typename T>
 void ostream_helper(T v)
 {
     not_null<T*> p(&v);
     {
         std::ostringstream os;
         std::ostringstream ref;
-        os << p;
-        ref << &v;
-        CHECK(os.str() == ref.str());
+        os << static_cast<void*>(p);
+        ref << static_cast<void*>(&v);
+        EXPECT_TRUE(os.str() == ref.str());
     }
     {
         std::ostringstream os;
         std::ostringstream ref;
         os << *p;
         ref << v;
-        CHECK(os.str() == ref.str());
+        EXPECT_TRUE(os.str() == ref.str());
     }
 }
 
-TEST_CASE("TestNotNullostream")
+TEST(notnull_tests, TestNotNullostream)
 {
     ostream_helper<int>(17);
     ostream_helper<float>(21.5f);
-    ostream_helper<double>(3.4566e-7f);
+    ostream_helper<double>(3.4566e-7);
     ostream_helper<char>('c');
     ostream_helper<uint16_t>(0x0123u);
     ostream_helper<const char*>("cstring");
     ostream_helper<std::string>("string");
 }
 
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("TestNotNullCasting")
+TEST(notnull_tests, TestNotNullCasting)
 {
     MyBase base;
     MyDerived derived;
@@ -212,7 +260,7 @@ TEST_CASE("TestNotNullCasting")
     not_null<MyDerived*> p{&derived};
     not_null<MyBase*> q(&base);
     q = p; // allowed with heterogeneous copy ctor
-    CHECK(q == p);
+    EXPECT_TRUE(q == p);
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     q = u; // no viable conversion possible between MyBase* and Unrelated*
@@ -222,20 +270,25 @@ TEST_CASE("TestNotNullCasting")
     not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
 #endif
     not_null<Unrelated*> t(reinterpret_cast<Unrelated*>(p.get()));
-    CHECK(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
+    EXPECT_TRUE(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
 }
 
-TEST_CASE("TestNotNullAssignment")
+TEST(notnull_tests, TestNotNullAssignment)
 {
+    std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullAssignmentd";
+        std::abort();
+    });
+
     int i = 12;
     not_null<int*> p(&i);
-    CHECK(helper(p));
+    EXPECT_TRUE(helper(p));
 
     int* q = nullptr;
-    CHECK_THROWS_AS(p = not_null<int*>(q), fail_fast);
+    EXPECT_DEATH(p = not_null<int*>(q), deathstring);
 }
 
-TEST_CASE("TestNotNullRawPointerComparison")
+TEST(notnull_tests, TestNotNullRawPointerComparison)
 {
     int ints[2] = {42, 43};
     int* p1 = &ints[0];
@@ -244,34 +297,33 @@ TEST_CASE("TestNotNullRawPointerComparison")
     using NotNull1 = not_null<decltype(p1)>;
     using NotNull2 = not_null<decltype(p2)>;
 
-    CHECK((NotNull1(p1) == NotNull1(p1)) == true);
-    CHECK((NotNull1(p1) == NotNull2(p2)) == false);
+    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == true);
+    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == false);
 
-    CHECK((NotNull1(p1) != NotNull1(p1)) == false);
-    CHECK((NotNull1(p1) != NotNull2(p2)) == true);
+    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == true);
 
-    CHECK((NotNull1(p1) < NotNull1(p1)) == false);
-    CHECK((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
-    CHECK((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
+    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
+    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
 
-    CHECK((NotNull1(p1) > NotNull1(p1)) == false);
-    CHECK((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
-    CHECK((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
+    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
+    EXPECT_TRUE((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));
+    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == true);
+    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
+    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("TestNotNullDereferenceOperator")
+TEST(notnull_tests, 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));
+        EXPECT_TRUE(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
+        EXPECT_TRUE(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
     }
 
     {
@@ -279,22 +331,22 @@ TEST_CASE("TestNotNullDereferenceOperator")
         CustomPtr<int> p1(&ints[0]);
 
         using NotNull1 = not_null<decltype(p1)>;
-        CHECK(typeid(*NotNull1(p1)) == typeid(*p1));
-        CHECK(*NotNull1(p1) == 42);
+        EXPECT_TRUE(typeid(*NotNull1(p1)) == typeid(*p1));
+        EXPECT_TRUE(*NotNull1(p1) == 42);
         *NotNull1(p1) = 43;
-        CHECK(ints[0] == 43);
+        EXPECT_TRUE(ints[0] == 43);
     }
 
     {
         int v = 42;
         gsl::not_null<int*> p(&v);
-        CHECK(typeid(*p) == typeid(*(&v)));
+        EXPECT_TRUE(typeid(*p) == typeid(*(&v)));
         *p = 43;
-        CHECK(v == 43);
+        EXPECT_TRUE(v == 43);
     }
 }
 
-TEST_CASE("TestNotNullSharedPtrComparison")
+TEST(notnull_tests, TestNotNullSharedPtrComparison)
 {
     auto sp1 = std::make_shared<int>(42);
     auto sp2 = std::make_shared<const int>(43);
@@ -302,31 +354,30 @@ TEST_CASE("TestNotNullSharedPtrComparison")
     using NotNullSp1 = not_null<decltype(sp1)>;
     using NotNullSp2 = not_null<decltype(sp2)>;
 
-    CHECK((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
-    CHECK((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);
 
-    CHECK((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
-    CHECK((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);
 
-    CHECK((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
-    CHECK((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
-    CHECK((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));
+    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));
 
-    CHECK((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
-    CHECK((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
-    CHECK((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));
+    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));
 
-    CHECK((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
-    CHECK((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
-    CHECK((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));
+    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));
 
-    CHECK((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
-    CHECK((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
-    CHECK((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
+    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("TestNotNullCustomPtrComparison")
+TEST(notnull_tests, TestNotNullCustomPtrComparison)
 {
     int ints[2] = {42, 43};
     CustomPtr<int> p1(&ints[0]);
@@ -335,33 +386,32 @@ TEST_CASE("TestNotNullCustomPtrComparison")
     using NotNull1 = not_null<decltype(p1)>;
     using NotNull2 = not_null<decltype(p2)>;
 
-    CHECK((NotNull1(p1) == NotNull1(p1)) == "true");
-    CHECK((NotNull1(p1) == NotNull2(p2)) == "false");
+    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == "false");
 
-    CHECK((NotNull1(p1) != NotNull1(p1)) == "false");
-    CHECK((NotNull1(p1) != NotNull2(p2)) == "true");
+    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == "true");
 
-    CHECK((NotNull1(p1) < NotNull1(p1)) == "false");
-    CHECK((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
-    CHECK((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
+    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
+    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
 
-    CHECK((NotNull1(p1) > NotNull1(p1)) == "false");
-    CHECK((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
-    CHECK((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
+    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
+    EXPECT_TRUE((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));
+    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
+    EXPECT_TRUE((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));
+    EXPECT_TRUE((NotNull1(p1) >= NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
+    EXPECT_TRUE((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
 }
 
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("TestNotNullConstructorTypeDeduction")
+TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
 {
     {
         int i = 42;
@@ -370,7 +420,7 @@ TEST_CASE("TestNotNullConstructorTypeDeduction")
         helper(not_null{&i});
         helper_const(not_null{&i});
 
-        CHECK(*x == 42);
+        EXPECT_TRUE(*x == 42);
     }
 
     {
@@ -381,15 +431,20 @@ TEST_CASE("TestNotNullConstructorTypeDeduction")
         helper(not_null{p});
         helper_const(not_null{p});
 
-        CHECK(*x == 42);
+        EXPECT_TRUE(*x == 42);
     }
 
+    std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullConstructorTypeDeduction";
+        std::abort();
+    });
+
     {
         auto workaround_macro = []() {
             int* p1 = nullptr;
             const not_null x{p1};
         };
-        CHECK_THROWS_AS(workaround_macro(), fail_fast);
+        EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
     {
@@ -397,14 +452,14 @@ TEST_CASE("TestNotNullConstructorTypeDeduction")
             const int* p1 = nullptr;
             const not_null x{p1};
         };
-        CHECK_THROWS_AS(workaround_macro(), fail_fast);
+        EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
     {
         int* p = nullptr;
 
-        CHECK_THROWS_AS(helper(not_null{p}), fail_fast);
-        CHECK_THROWS_AS(helper_const(not_null{p}), fail_fast);
+        EXPECT_DEATH(helper(not_null{p}), deathstring);
+        EXPECT_DEATH(helper_const(not_null{p}), deathstring);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
@@ -417,7 +472,7 @@ TEST_CASE("TestNotNullConstructorTypeDeduction")
 }
 #endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)
 
-TEST_CASE("TestMakeNotNull")
+TEST(notnull_tests, TestMakeNotNull)
 {
     {
         int i = 42;
@@ -426,7 +481,7 @@ TEST_CASE("TestMakeNotNull")
         helper(make_not_null(&i));
         helper_const(make_not_null(&i));
 
-        CHECK(*x == 42);
+        EXPECT_TRUE(*x == 42);
     }
 
     {
@@ -437,42 +492,44 @@ TEST_CASE("TestMakeNotNull")
         helper(make_not_null(p));
         helper_const(make_not_null(p));
 
-        CHECK(*x == 42);
+        EXPECT_TRUE(*x == 42);
     }
 
+    std::set_terminate([] {
+        std::cerr << "Expected Death. TestMakeNotNull";
+        std::abort();
+    });
+
     {
         const auto workaround_macro = []() {
             int* p1 = nullptr;
             const auto x = make_not_null(p1);
-            CHECK(*x == 42);
+            EXPECT_TRUE(*x == 42);
         };
-        CHECK_THROWS_AS(workaround_macro(), fail_fast);
+        EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
     {
         const auto workaround_macro = []() {
             const int* p1 = nullptr;
             const auto x = make_not_null(p1);
-            CHECK(*x == 42);
+            EXPECT_TRUE(*x == 42);
         };
-        CHECK_THROWS_AS(workaround_macro(), fail_fast);
+        EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
     {
         int* p = nullptr;
 
-        CHECK_THROWS_AS(helper(make_not_null(p)), fail_fast);
-        CHECK_THROWS_AS(helper_const(make_not_null(p)), fail_fast);
+        EXPECT_DEATH(helper(make_not_null(p)), deathstring);
+        EXPECT_DEATH(helper_const(make_not_null(p)), deathstring);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     {
-        CHECK_THROWS_AS(make_not_null(nullptr), fail_fast);
-        CHECK_THROWS_AS(helper(make_not_null(nullptr)), fail_fast);
-        CHECK_THROWS_AS(helper_const(make_not_null(nullptr)), fail_fast);
+        EXPECT_DEATH(make_not_null(nullptr), deathstring);
+        EXPECT_DEATH(helper(make_not_null(nullptr)), deathstring);
+        EXPECT_DEATH(helper_const(make_not_null(nullptr)), deathstring);
     }
 #endif
 }
-
-static_assert(std::is_nothrow_move_constructible<not_null<void *>>::value, "not_null must be no-throw move constructible");
-

tests/owner_tests.cpp

@@ -14,14 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
+#include <gtest/gtest.h>
 
 #include <gsl/pointers> // for owner
 
@@ -30,19 +23,16 @@ using namespace gsl;
 GSL_SUPPRESS(f.23) // NO-FORMAT: attribute
 void f(int* i) { *i += 1; }
 
-GSL_SUPPRESS(r.11) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.3) // NO-FORMAT: attribute // TODO: false positive
-GSL_SUPPRESS(r.5) // NO-FORMAT: attribute
-TEST_CASE("basic_test")
+TEST(owner_tests, basic_test)
 {
     owner<int*> p = new int(120);
-    CHECK(*p == 120);
+    EXPECT_TRUE(*p == 120);
     f(p);
-    CHECK(*p == 121);
+    EXPECT_TRUE(*p == 121);
     delete p;
 }
 
-TEST_CASE("check_pointer_constraint")
+TEST(owner_tests, check_pointer_constraint)
 {
     #ifdef CONFIRM_COMPILATION_ERRORS
     {

tests/sloppy_notnull_tests.cpp

@@ -1,124 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-
-// Fix VS2015 build breaks in Release
-#pragma warning(disable : 4702) // unreachable code
-#endif
-
-#include <catch/catch.hpp>    // for AssertionHandler, StringRef, CHECK, TEST_...
-
-#include <gsl/pointers>           // for not_null, operator<, operator<=, operator>
-#include <samples/gsl_transition> // for sloppy_not_null
-
-namespace gsl
-{
-struct fail_fast;
-} // namespace gsl
-
-using namespace gsl;
-using namespace gsl_helpers;
-
-GSL_SUPPRESS(f.4)  // NO-FORMAT: attribute
-bool helper(not_null<int*> p) { return *p == 12; }
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-bool helper_const(not_null<const int*> p) { return *p == 12; }
-
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-bool sloppy_helper(sloppy_not_null<int*> p) { return *p == 12; }
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
-bool sloppy_helper_const(sloppy_not_null<const int*> p) { return *p == 12; }
-
-TEST_CASE("TestSloppyNotNull")
-{
-    {
-        // raw ptr <-> sloppy_not_null
-        int x = 42;
-
-        const sloppy_not_null<int*> snn = &x;
-
-        sloppy_helper(&x);
-        sloppy_helper_const(&x);
-
-        CHECK(*snn == 42);
-    }
-
-    {
-        // sloppy_not_null -> sloppy_not_null
-        int x = 42;
-
-        sloppy_not_null<int*> snn1{&x};
-        const sloppy_not_null<int*> snn2{&x};
-
-        sloppy_helper(snn1);
-        sloppy_helper_const(snn1);
-
-        CHECK(snn1 == snn2);
-    }
-
-    {
-        // sloppy_not_null -> not_null
-        int x = 42;
-
-        sloppy_not_null<int*> snn{&x};
-
-        const not_null<int*> nn1 = snn;
-        const not_null<int*> nn2{snn};
-
-        helper(snn);
-        helper_const(snn);
-
-        CHECK(snn == nn1);
-        CHECK(snn == nn2);
-    }
-
-    {
-        // not_null -> sloppy_not_null
-        int x = 42;
-
-        not_null<int*> nn{&x};
-
-        const sloppy_not_null<int*> snn1{nn};
-        const sloppy_not_null<int*> snn2 = nn;
-
-        sloppy_helper(nn);
-        sloppy_helper_const(nn);
-
-        CHECK(snn1 == nn);
-        CHECK(snn2 == nn);
-
-        std::hash<sloppy_not_null<int*>> hash_snn;
-        std::hash<not_null<int*>> hash_nn;
-
-        CHECK(hash_nn(snn1) == hash_nn(nn));
-        CHECK(hash_snn(snn1) == hash_nn(nn));
-        CHECK(hash_nn(snn1) == hash_nn(snn2));
-        CHECK(hash_snn(snn1) == hash_snn(nn));
-    }
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-    {
-        sloppy_not_null<int*> p{nullptr};
-    }
-#endif
-}
-
-static_assert(std::is_nothrow_move_constructible<sloppy_not_null<void*>>::value,
-              "sloppy_not_null must be no-throw move constructible");

tests/span_ext_tests.cpp

@@ -0,0 +1,360 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/gsl_util> // for narrow_cast, at
+#include <gsl/span_ext> // for operator==, operator!=, make_span
+
+#include <array>       // for array
+#include <iostream>    // for cerr
+#include <vector>      // for vector
+
+using namespace std;
+using namespace gsl;
+
+namespace
+{
+static constexpr char deathstring[] = "Expected Death";
+} // namespace
+
+TEST(span_ext_test, make_span_from_pointer_length_constructor)
+{
+    std::set_terminate([] {
+        std::cerr << "Expected Death. from_pointer_length_constructor";
+        std::abort();
+    });
+    int arr[4] = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(&arr[0], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
+    }
+
+    {
+        int* p = nullptr;
+        auto s = make_span(p, narrow_cast<span<int>::size_type>(0));
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
+    }
+
+    {
+        int* p = nullptr;
+        auto workaround_macro = [=]() { make_span(p, 2); };
+        EXPECT_DEATH(workaround_macro(), deathstring);
+    }
+}
+
+TEST(span_ext_test, make_span_from_pointer_pointer_construction)
+{
+    int arr[4] = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(&arr[0], &arr[2]);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
+    }
+
+    {
+        auto s = make_span(&arr[0], &arr[0]);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
+    }
+
+    {
+        int* p = nullptr;
+        auto s = make_span(p, p);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
+    }
+}
+
+TEST(span_ext_test, make_span_from_array_constructor)
+ {
+     int arr[5] = {1, 2, 3, 4, 5};
+     int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
+     int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+     {
+         const auto s = make_span(arr);
+         EXPECT_TRUE(s.size() == 5);
+         EXPECT_TRUE(s.data() == std::addressof(arr[0]));
+     }
+
+     {
+         const auto s = make_span(std::addressof(arr2d[0]), 1);
+         EXPECT_TRUE(s.size() == 1);
+         EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
+     }
+
+     {
+         const auto s = make_span(std::addressof(arr3d[0]), 1);
+         EXPECT_TRUE(s.size() == 1);
+         EXPECT_TRUE(s.data() == std::addressof(arr3d[0]));
+     }
+ }
+
+ TEST(span_ext_test, make_span_from_dynamic_array_constructor)
+ {
+     double(*arr)[3][4] = new double[100][3][4];
+
+     {
+         auto s = make_span(&arr[0][0][0], 10);
+         EXPECT_TRUE(s.size() == 10);
+         EXPECT_TRUE(s.data() == &arr[0][0][0]);
+     }
+
+     delete[] arr;
+ }
+
+ TEST(span_ext_test, make_span_from_std_array_constructor)
+ {
+     std::array<int, 4> arr = {1, 2, 3, 4};
+
+     {
+         auto s = make_span(arr);
+         EXPECT_TRUE(s.size() == arr.size());
+         EXPECT_TRUE(s.data() == arr.data());
+     }
+
+     // This test checks for the bug found in gcc 6.1, 6.2, 6.3, 6.4, 6.5 7.1, 7.2, 7.3 - issue #590
+     {
+         span<int> s1 = make_span(arr);
+
+         static span<int> s2;
+         s2 = s1;
+
+ #if defined(__GNUC__) && __GNUC__ == 6 && (__GNUC_MINOR__ == 4 || __GNUC_MINOR__ == 5) &&          \
+     __GNUC_PATCHLEVEL__ == 0 && defined(__OPTIMIZE__)
+         // Known to be broken in gcc 6.4 and 6.5 with optimizations
+         // Issue in gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83116
+         EXPECT_TRUE(s1.size() == 4);
+         EXPECT_TRUE(s2.size() == 0);
+ #else
+         EXPECT_TRUE(s1.size() == s2.size());
+ #endif
+     }
+ }
+
+ TEST(span_ext_test, make_span_from_const_std_array_constructor)
+ {
+     const std::array<int, 4> arr = {1, 2, 3, 4};
+
+     {
+         auto s = make_span(arr);
+         EXPECT_TRUE(s.size() == arr.size());
+         EXPECT_TRUE(s.data() == arr.data());
+     }
+ }
+
+ TEST(span_ext_test, make_span_from_std_array_const_constructor)
+ {
+     std::array<const int, 4> arr = {1, 2, 3, 4};
+
+     {
+         auto s = make_span(arr);
+         EXPECT_TRUE(s.size() == arr.size());
+         EXPECT_TRUE(s.data() == arr.data());
+     }
+ }
+
+ TEST(span_ext_test, make_span_from_container_constructor)
+ {
+     std::vector<int> v = {1, 2, 3};
+     const std::vector<int> cv = v;
+
+     {
+         auto s = make_span(v);
+         EXPECT_TRUE(s.size() == v.size());
+         EXPECT_TRUE(s.data() == v.data());
+
+         auto cs = make_span(cv);
+         EXPECT_TRUE(cs.size() == cv.size());
+         EXPECT_TRUE(cs.data() == cv.data());
+     }
+ }
+
+ TEST(span_test, interop_with_gsl_at)
+ {
+     int arr[5] = {1, 2, 3, 4, 5};
+     span<int> s{arr};
+     EXPECT_TRUE(at(s, 0) ==  1);
+     EXPECT_TRUE(at(s, 1) == 2);
+ }
+
+ TEST(span_ext_test, iterator_free_functions)
+ {
+     int a[] = {1, 2, 3, 4};
+     span<int> s{a};
+
+     EXPECT_TRUE((std::is_same<decltype(s.begin()), decltype(begin(s))>::value));
+     EXPECT_TRUE((std::is_same<decltype(s.end()), decltype(end(s))>::value));
+
+     EXPECT_TRUE((std::is_same<decltype(std::cbegin(s)), decltype(cbegin(s))>::value));
+     EXPECT_TRUE((std::is_same<decltype(std::cend(s)), decltype(cend(s))>::value));
+
+     EXPECT_TRUE((std::is_same<decltype(s.rbegin()), decltype(rbegin(s))>::value));
+     EXPECT_TRUE((std::is_same<decltype(s.rend()), decltype(rend(s))>::value));
+
+     EXPECT_TRUE((std::is_same<decltype(std::crbegin(s)), decltype(crbegin(s))>::value));
+     EXPECT_TRUE((std::is_same<decltype(std::crend(s)), decltype(crend(s))>::value));
+
+     EXPECT_TRUE(s.begin() == begin(s));
+     EXPECT_TRUE(s.end() == end(s));
+
+     EXPECT_TRUE(s.rbegin() == rbegin(s));
+     EXPECT_TRUE(s.rend() == rend(s));
+
+     EXPECT_TRUE(s.begin() == cbegin(s));
+     EXPECT_TRUE(s.end() == cend(s));
+
+     EXPECT_TRUE(s.rbegin() == crbegin(s));
+     EXPECT_TRUE(s.rend() == crend(s));
+ }
+
+ TEST(span_ext_test, ssize_free_function)
+ {
+     int a[] = {1, 2, 3, 4};
+     span<int> s{a};
+
+     EXPECT_FALSE((std::is_same<decltype(s.size()), decltype(ssize(s))>::value));
+     EXPECT_TRUE(s.size() == static_cast<std::size_t>(ssize(s)));
+ }
+
+  TEST(span_ext_test, comparison_operators)
+ {
+     {
+         span<int> s1;
+         span<int> s2;
+         EXPECT_TRUE(s1 == s2);
+         EXPECT_FALSE(s1 != s2);
+         EXPECT_FALSE(s1 < s2);
+         EXPECT_TRUE(s1 <= s2);
+         EXPECT_FALSE(s1 > s2);
+         EXPECT_TRUE(s1 >= s2);
+         EXPECT_TRUE(s2 == s1);
+         EXPECT_FALSE(s2 != s1);
+         EXPECT_FALSE(s2 != s1);
+         EXPECT_TRUE(s2 <= s1);
+         EXPECT_FALSE(s2 > s1);
+         EXPECT_TRUE(s2 >= s1);
+     }
+
+     {
+         int arr[] = {2, 1};
+         span<int> s1 = arr;
+         span<int> s2 = arr;
+
+         EXPECT_TRUE(s1 == s2);
+         EXPECT_FALSE(s1 != s2);
+         EXPECT_FALSE(s1 < s2);
+         EXPECT_TRUE(s1 <= s2);
+         EXPECT_FALSE(s1 > s2);
+         EXPECT_TRUE(s1 >= s2);
+         EXPECT_TRUE(s2 == s1);
+         EXPECT_FALSE(s2 != s1);
+         EXPECT_FALSE(s2 < s1);
+         EXPECT_TRUE(s2 <= s1);
+         EXPECT_FALSE(s2 > s1);
+         EXPECT_TRUE(s2 >= s1);
+     }
+
+     {
+         int arr[] = {2, 1}; // bigger
+
+         span<int> s1;
+         span<int> s2 = arr;
+
+         EXPECT_TRUE(s1 != s2);
+         EXPECT_TRUE(s2 != s1);
+         EXPECT_FALSE(s1 == s2);
+         EXPECT_FALSE(s2 == s1);
+         EXPECT_TRUE(s1 < s2);
+         EXPECT_FALSE(s2 < s1);
+         EXPECT_TRUE(s1 <= s2);
+         EXPECT_FALSE(s2 <= s1);
+         EXPECT_TRUE(s2 > s1);
+         EXPECT_FALSE(s1 > s2);
+         EXPECT_TRUE(s2 >= s1);
+         EXPECT_FALSE(s1 >= s2);
+     }
+
+     {
+         int arr1[] = {1, 2};
+         int arr2[] = {1, 2};
+         span<int> s1 = arr1;
+         span<int> s2 = arr2;
+
+         EXPECT_TRUE(s1 == s2);
+         EXPECT_FALSE(s1 != s2);
+         EXPECT_FALSE(s1 < s2);
+         EXPECT_TRUE(s1 <= s2);
+         EXPECT_FALSE(s1 > s2);
+         EXPECT_TRUE(s1 >= s2);
+         EXPECT_TRUE(s2 == s1);
+         EXPECT_FALSE(s2 != s1);
+         EXPECT_FALSE(s2 < s1);
+         EXPECT_TRUE(s2 <= s1);
+         EXPECT_FALSE(s2 > s1);
+         EXPECT_TRUE(s2 >= s1);
+     }
+
+     {
+         int arr[] = {1, 2, 3};
+
+         span<int> s1 = {&arr[0], 2}; // shorter
+         span<int> s2 = arr;          // longer
+
+         EXPECT_TRUE(s1 != s2);
+         EXPECT_TRUE(s2 != s1);
+         EXPECT_FALSE(s1 == s2);
+         EXPECT_FALSE(s2 == s1);
+         EXPECT_TRUE(s1 < s2);
+         EXPECT_FALSE(s2 < s1);
+         EXPECT_TRUE(s1 <= s2);
+         EXPECT_FALSE(s2 <= s1);
+         EXPECT_TRUE(s2 > s1);
+         EXPECT_FALSE(s1 > s2);
+         EXPECT_TRUE(s2 >= s1);
+         EXPECT_FALSE(s1 >= s2);
+     }
+
+     {
+         int arr1[] = {1, 2}; // smaller
+         int arr2[] = {2, 1}; // bigger
+
+         span<int> s1 = arr1;
+         span<int> s2 = arr2;
+
+         EXPECT_TRUE(s1 != s2);
+         EXPECT_TRUE(s2 != s1);
+         EXPECT_FALSE(s1 == s2);
+         EXPECT_FALSE(s2 == s1);
+         EXPECT_TRUE(s1 < s2);
+         EXPECT_FALSE(s2 < s1);
+         EXPECT_TRUE(s1 <= s2);
+         EXPECT_FALSE(s2 <= s1);
+         EXPECT_TRUE(s2 > s1);
+         EXPECT_FALSE(s1 > s2);
+         EXPECT_TRUE(s2 >= s1);
+         EXPECT_FALSE(s1 >= s2);
+     }
+ }

tests/strict_notnull_tests.cpp

@@ -0,0 +1,190 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+#include <gsl/pointers>           // for not_null, operator<, operator<=, operator>
+
+namespace gsl
+{
+struct fail_fast;
+} // namespace gsl
+
+using namespace gsl;
+
+GSL_SUPPRESS(f.4)  // NO-FORMAT: attribute
+bool helper(not_null<int*> p) { return *p == 12; }
+
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+bool helper_const(not_null<const int*> p) { return *p == 12; }
+
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+bool strict_helper(strict_not_null<int*> p) { return *p == 12; }
+
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+bool strict_helper_const(strict_not_null<const int*> p) { return *p == 12; }
+
+int* return_pointer() { return nullptr; }
+const int* return_pointer_const() { return nullptr; }
+
+TEST(strict_notnull_tests, TestStrictNotNull)
+{
+    {
+        // raw ptr <-> strict_not_null
+        int x = 42;
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_not_null<int*> snn = &x;
+        strict_helper(&x);
+        strict_helper_const(&x);
+        strict_helper(return_pointer());
+        strict_helper_const(return_pointer_const());
+#endif
+
+        const strict_not_null<int*> snn1{&x};
+
+        helper(snn1);
+        helper_const(snn1);
+
+        EXPECT_TRUE(*snn1 == 42);
+    }
+
+    {
+        // strict_not_null -> strict_not_null
+        int x = 42;
+
+        strict_not_null<int*> snn1{&x};
+        const strict_not_null<int*> snn2{&x};
+
+        strict_helper(snn1);
+        strict_helper_const(snn1);
+        strict_helper_const(snn2);
+
+        EXPECT_TRUE(snn1 == snn2);
+    }
+
+    {
+        // strict_not_null -> not_null
+        int x = 42;
+
+        strict_not_null<int*> snn{&x};
+
+        const not_null<int*> nn1 = snn;
+        const not_null<int*> nn2{snn};
+
+        helper(snn);
+        helper_const(snn);
+
+        EXPECT_TRUE(snn == nn1);
+        EXPECT_TRUE(snn == nn2);
+    }
+
+    {
+        // not_null -> strict_not_null
+        int x = 42;
+
+        not_null<int*> nn{&x};
+
+        const strict_not_null<int*> snn1{nn};
+        const strict_not_null<int*> snn2{nn};
+
+        strict_helper(nn);
+        strict_helper_const(nn);
+
+        EXPECT_TRUE(snn1 == nn);
+        EXPECT_TRUE(snn2 == nn);
+
+        std::hash<strict_not_null<int*>> hash_snn;
+        std::hash<not_null<int*>> hash_nn;
+
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
+        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        strict_not_null<int*> p{nullptr};
+    }
+#endif
+}
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+namespace
+{
+static constexpr char deathstring[] = "Expected Death";
+}
+
+TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
+{
+    std::set_terminate([] {
+        std::cerr << "Expected Death. TestStrictNotNullConstructorTypeDeduction";
+        std::abort();
+    });
+
+    {
+        int i = 42;
+
+        strict_not_null x{&i};
+        helper(strict_not_null{&i});
+        helper_const(strict_not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        strict_not_null x{p};
+        helper(strict_not_null{p});
+        helper_const(strict_not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const strict_not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), deathstring);
+    }
+
+    {
+        auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const strict_not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), deathstring);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(strict_not_null{p}), deathstring);
+        EXPECT_DEATH(helper_const(strict_not_null{p}), deathstring);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        strict_not_null x{nullptr};
+        helper(strict_not_null{nullptr});
+        helper_const(strict_not_null{nullptr});
+    }
+#endif
+}
+#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)

tests/strided_span_tests.cpp

@@ -14,15 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, CHECK...
-
+#include <gtest/gtest.h>
 #include <gsl/gsl_byte>   // for byte
 #include <gsl/gsl_util>   // for narrow_cast
 #include <gsl/multi_span> // for strided_span, index, multi_span, strided_...
@@ -33,24 +25,80 @@
 #include <type_traits> // for integral_constant<>::value, is_convertible
 #include <vector>      // for vector
 
-namespace gsl {
-struct fail_fast;
-}  // namespace gsl
-
 using namespace std;
 using namespace gsl;
 
+
 namespace
 {
+static constexpr char deathstring[] = "Expected Death";
+
 struct BaseClass
 {
 };
 struct DerivedClass : BaseClass
 {
 };
+
+GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+void iterate_every_other_element(multi_span<int, dynamic_range> av)
+{
+    // pick every other element
+
+    auto length = av.size() / 2;
+#if defined(_MSC_VER) && _MSC_VER > 1800
+    auto bounds = strided_bounds<1>({length}, {2});
+#else
+    auto bounds = strided_bounds<1>(multi_span_index<1>{length}, multi_span_index<1>{2});
+#endif
+    strided_span<int, 1> strided(&av.data()[1], av.size() - 1, bounds);
+
+    EXPECT_TRUE(strided.size() == length);
+    EXPECT_TRUE(strided.bounds().index_bounds()[0] == length);
+    for (auto i = 0; i < strided.size(); ++i) {
+        EXPECT_TRUE(strided[i] == av[2 * i + 1]);
+    }
+
+    int idx = 0;
+    for (auto num : strided) {
+        EXPECT_TRUE(num == av[2 * idx + 1]);
+        idx++;
+    }
 }
 
-TEST_CASE("span_section_test")
+GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute // TODO: does not work
+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});
+
+    for (auto i = 0; i < section.extent<0>(); ++i) {
+        for (auto j = 0; j < section.extent<1>(); ++j)
+            for (auto k = 0; k < section.extent<2>(); ++k) {
+                auto idx = multi_span_index<3>{i, j, k}; // avoid braces in the EXPECT_TRUE macro
+                EXPECT_TRUE(section[idx] == expected[2 * i + 2 * j + k]);
+            }
+    }
+
+    for (auto i = 0; i < section.extent<0>(); ++i) {
+        for (auto j = 0; j < section.extent<1>(); ++j)
+            for (auto k = 0; k < section.extent<2>(); ++k)
+                EXPECT_TRUE(section[i][j][k] == expected[2 * i + 2 * j + k]);
+    }
+
+    int i = 0;
+    for (const auto num : section) {
+        EXPECT_TRUE(num == expected[i]);
+        i++;
+    }
+}
+
+}
+
+TEST(strided_span_tests, span_section_test)
 {
     int a[30][4][5];
 
@@ -60,51 +108,54 @@ TEST_CASE("span_section_test")
     (void) subsub;
 }
 
-TEST_CASE("span_section")
+TEST(strided_span_tests, 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>());
 
     const strided_span<int, 2> av_section_1 = av.section({1, 2}, {3, 4});
-    CHECK(!av_section_1.empty());
-    CHECK((av_section_1[{0, 0}] == 12));
-    CHECK((av_section_1[{0, 1}] == 13));
-    CHECK((av_section_1[{1, 0}] == 22));
-    CHECK((av_section_1[{2, 3}] == 35));
+    EXPECT_TRUE(!av_section_1.empty());
+    EXPECT_TRUE((av_section_1[{0, 0}] == 12));
+    EXPECT_TRUE((av_section_1[{0, 1}] == 13));
+    EXPECT_TRUE((av_section_1[{1, 0}] == 22));
+    EXPECT_TRUE((av_section_1[{2, 3}] == 35));
 
     const strided_span<int, 2> av_section_2 = av_section_1.section({1, 2}, {2, 2});
-    CHECK(!av_section_2.empty());
-    CHECK((av_section_2[{0, 0}] == 24));
-    CHECK((av_section_2[{0, 1}] == 25));
-    CHECK((av_section_2[{1, 0}] == 34));
+    EXPECT_TRUE(!av_section_2.empty());
+    EXPECT_TRUE((av_section_2[{0, 0}] == 24));
+    EXPECT_TRUE((av_section_2[{0, 1}] == 25));
+    EXPECT_TRUE((av_section_2[{1, 0}] == 34));
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("strided_span_constructors")
+TEST(strided_span_tests, strided_span_constructors)
 {
-    // Check stride constructor
+    // EXPECT_TRUE stride constructor
     {
         int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
         const int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 
         strided_span<int, 1> sav1{arr, {{9}, {1}}}; // T -> T
-        CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{9});
-        CHECK(sav1.bounds().stride() == 1);
-        CHECK((sav1[0] == 1 && sav1[8] == 9));
+        EXPECT_TRUE(sav1.bounds().index_bounds() == multi_span_index<1>{9});
+        EXPECT_TRUE(sav1.bounds().stride() == 1);
+        EXPECT_TRUE(sav1[0] == 1);
+        EXPECT_TRUE(sav1[8] == 9);
 
         strided_span<const int, 1> sav2{carr, {{4}, {2}}}; // const T -> const T
-        CHECK(sav2.bounds().index_bounds() == multi_span_index<1>{4});
-        CHECK(sav2.bounds().strides() == multi_span_index<1>{2});
-        CHECK((sav2[0] == 1 && sav2[3] == 7));
+        EXPECT_TRUE(sav2.bounds().index_bounds() == multi_span_index<1>{4});
+        EXPECT_TRUE(sav2.bounds().strides() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav2[0] == 1);
+        EXPECT_TRUE(sav2[3] == 7);
 
         strided_span<int, 2> sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T
-        CHECK((sav3.bounds().index_bounds() == multi_span_index<2>{2, 2}));
-        CHECK((sav3.bounds().strides() == multi_span_index<2>{6, 2}));
-        CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7));
+        EXPECT_TRUE((sav3.bounds().index_bounds() == multi_span_index<2>{2, 2}));
+        EXPECT_TRUE((sav3.bounds().strides() == multi_span_index<2>{6, 2}));
+        EXPECT_TRUE((sav3[{0, 0}]) == 1);
+        EXPECT_TRUE((sav3[{0, 1}]) ==  3);
+        EXPECT_TRUE((sav3[{1, 0}]) == 7);
     }
 
-    // Check multi_span constructor
+    // EXPECT_TRUE multi_span constructor
     {
         int arr[] = {1, 2};
 
@@ -113,11 +164,11 @@ TEST_CASE("strided_span_constructors")
             const multi_span<int> src = arr;
 
             strided_span<int, 1> sav{src, {2, 1}};
-            CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav[1] == 2);
+            EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav[1] == 2);
 
-#if _MSC_VER > 1800
+#if defined(_MSC_VER) && _MSC_VER > 1800
             // strided_span<const int, 1> sav_c{ {src}, {2, 1} };
             strided_span<const int, 1> sav_c{multi_span<const int>{src},
                                              strided_bounds<1>{2, 1}};
@@ -125,29 +176,29 @@ TEST_CASE("strided_span_constructors")
             strided_span<const int, 1> sav_c{multi_span<const int>{src},
                                              strided_bounds<1>{2, 1}};
 #endif
-            CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_c.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_c[1] == 2);
+            EXPECT_TRUE(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_c.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_c[1] == 2);
 
-#if _MSC_VER > 1800
+#if defined(_MSC_VER) && _MSC_VER > 1800
             strided_span<volatile int, 1> sav_v{src, {2, 1}};
 #else
             strided_span<volatile int, 1> sav_v{multi_span<volatile int>{src},
                                                 strided_bounds<1>{2, 1}};
 #endif
-            CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_v.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_v[1] == 2);
+            EXPECT_TRUE(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_v.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_v[1] == 2);
 
-#if _MSC_VER > 1800
+#if defined(_MSC_VER) && _MSC_VER > 1800
             strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
 #else
             strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
                                                        strided_bounds<1>{2, 1}};
 #endif
-            CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_cv[1] == 2);
+            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_cv[1] == 2);
         }
 
         // From const-qualified source
@@ -155,20 +206,20 @@ TEST_CASE("strided_span_constructors")
             const multi_span<const int> src{arr};
 
             strided_span<const int, 1> sav_c{src, {2, 1}};
-            CHECK(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_c.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_c[1] == 2);
+            EXPECT_TRUE(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_c.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_c[1] == 2);
 
-#if _MSC_VER > 1800
+#if defined(_MSC_VER) && _MSC_VER > 1800
             strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
 #else
             strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
                                                        strided_bounds<1>{2, 1}};
 #endif
 
-            CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_cv[1] == 2);
+            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_cv[1] == 2);
         }
 
         // From volatile-qualified source
@@ -176,19 +227,19 @@ TEST_CASE("strided_span_constructors")
             const multi_span<volatile int> src{arr};
 
             strided_span<volatile int, 1> sav_v{src, {2, 1}};
-            CHECK(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_v.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_v[1] == 2);
+            EXPECT_TRUE(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_v.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_v[1] == 2);
 
-#if _MSC_VER > 1800
+#if defined(_MSC_VER) && _MSC_VER > 1800
             strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
 #else
             strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
                                                        strided_bounds<1>{2, 1}};
 #endif
-            CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_cv[1] == 2);
+            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_cv[1] == 2);
         }
 
         // From cv-qualified source
@@ -196,19 +247,19 @@ TEST_CASE("strided_span_constructors")
             const multi_span<const volatile int> src{arr};
 
             strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
-            CHECK(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
-            CHECK(sav_cv.bounds().strides() == multi_span_index<1>{1});
-            CHECK(sav_cv[1] == 2);
+            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
+            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
+            EXPECT_TRUE(sav_cv[1] == 2);
         }
     }
 
-    // Check const-casting constructor
+    // EXPECT_TRUE const-casting constructor
     {
         int arr[2] = {4, 5};
 
         const multi_span<int, 2> av(arr, 2);
         multi_span<const int, 2> av2{av};
-        CHECK(av2[1] == 5);
+        EXPECT_TRUE(av2[1] == 5);
 
         static_assert(
             std::is_convertible<const multi_span<int, 2>, multi_span<const int, 2>>::value,
@@ -216,34 +267,35 @@ TEST_CASE("strided_span_constructors")
 
         const strided_span<int, 1> src{arr, {2, 1}};
         strided_span<const int, 1> sav{src};
-        CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
-        CHECK(sav.bounds().stride() == 1);
-        CHECK(sav[1] == 5);
+        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav.bounds().stride() == 1);
+        EXPECT_TRUE(sav[1] == 5);
 
         static_assert(
             std::is_convertible<const strided_span<int, 1>, strided_span<const int, 1>>::value,
             "ctor is not implicit!");
     }
 
-    // Check copy constructor
+    // EXPECT_TRUE copy constructor
     {
         int arr1[2] = {3, 4};
         const strided_span<int, 1> src1{arr1, {2, 1}};
         strided_span<int, 1> sav1{src1};
 
-        CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{2});
-        CHECK(sav1.bounds().stride() == 1);
-        CHECK(sav1[0] == 3);
+        EXPECT_TRUE(sav1.bounds().index_bounds() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav1.bounds().stride() == 1);
+        EXPECT_TRUE(sav1[0] == 3);
 
         int arr2[6] = {1, 2, 3, 4, 5, 6};
         const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
         strided_span<const int, 2> sav2{src2};
-        CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
-        CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
-        CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
+        EXPECT_TRUE((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
+        EXPECT_TRUE((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
+        EXPECT_TRUE((sav2[{0, 0}]) ==  1);
+        EXPECT_TRUE((sav2[{2, 0}]) == 5);
     }
 
-    // Check const-casting assignment operator
+    // EXPECT_TRUE const-casting assignment operator
     {
         int arr1[2] = {1, 2};
         int arr2[6] = {3, 4, 5, 6, 7, 8};
@@ -251,38 +303,38 @@ TEST_CASE("strided_span_constructors")
         const strided_span<int, 1> src{arr1, {{2}, {1}}};
         strided_span<const int, 1> sav{arr2, {{3}, {2}}};
         strided_span<const int, 1>& sav_ref = (sav = src);
-        CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
-        CHECK(sav.bounds().strides() == multi_span_index<1>{1});
-        CHECK(sav[0] == 1);
-        CHECK(&sav_ref == &sav);
+        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav.bounds().strides() == multi_span_index<1>{1});
+        EXPECT_TRUE(sav[0] == 1);
+        EXPECT_TRUE(&sav_ref == &sav);
     }
 
-    // Check copy assignment operator
+    // EXPECT_TRUE copy assignment operator
     {
         int arr1[2] = {3, 4};
         int arr1b[1] = {0};
         const strided_span<int, 1> src1{arr1, {2, 1}};
         strided_span<int, 1> sav1{arr1b, {1, 1}};
         strided_span<int, 1>& sav1_ref = (sav1 = src1);
-        CHECK(sav1.bounds().index_bounds() == multi_span_index<1>{2});
-        CHECK(sav1.bounds().strides() == multi_span_index<1>{1});
-        CHECK(sav1[0] == 3);
-        CHECK(&sav1_ref == &sav1);
+        EXPECT_TRUE(sav1.bounds().index_bounds() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav1.bounds().strides() == multi_span_index<1>{1});
+        EXPECT_TRUE(sav1[0] == 3);
+        EXPECT_TRUE(&sav1_ref == &sav1);
 
         const int arr2[6] = {1, 2, 3, 4, 5, 6};
         const int arr2b[1] = {0};
         const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
         strided_span<const int, 2> sav2{arr2b, {{1, 1}, {1, 1}}};
         strided_span<const int, 2>& sav2_ref = (sav2 = src2);
-        CHECK((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
-        CHECK((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
-        CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5));
-        CHECK(&sav2_ref == &sav2);
+        EXPECT_TRUE((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
+        EXPECT_TRUE((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
+        EXPECT_TRUE((sav2[{0, 0}] == 1));
+        EXPECT_TRUE((sav2[{2, 0}] == 5));
+        EXPECT_TRUE(&sav2_ref == &sav2);
     }
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("strided_span_slice")
+TEST(strided_span_tests, strided_span_slice)
 {
     std::vector<int> data(5 * 10);
     std::iota(begin(data), end(data), 0);
@@ -297,19 +349,18 @@ TEST_CASE("strided_span_slice")
                                           {{5, 10}, {10, 1}}};
 
     strided_span<int, 1> sav_sl = sav[2];
-    CHECK(sav_sl[0] == 20);
-    CHECK(sav_sl[9] == 29);
+    EXPECT_TRUE(sav_sl[0] == 20);
+    EXPECT_TRUE(sav_sl[9] == 29);
 
     strided_span<const int, 1> csav_sl = sav[3];
-    CHECK(csav_sl[0] == 30);
-    CHECK(csav_sl[9] == 39);
+    EXPECT_TRUE(csav_sl[0] == 30);
+    EXPECT_TRUE(csav_sl[9] == 39);
 
-    CHECK(sav[4][0] == 40);
-    CHECK(sav[4][9] == 49);
+    EXPECT_TRUE(sav[4][0] == 40);
+    EXPECT_TRUE(sav[4][9] == 49);
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("strided_span_column_major")
+TEST(strided_span_tests, strided_span_column_major)
 {
     // strided_span may be used to accommodate more peculiar
     // use cases, such as column-major multidimensional array
@@ -319,119 +370,123 @@ TEST_CASE("strided_span_column_major")
     strided_span<int, 2> cm_sav{cm_array, {{5, 3}, {1, 5}}};
 
     // Accessing elements
-    CHECK((cm_sav[{0, 0}] == 1));
-    CHECK((cm_sav[{0, 1}] == 2));
-    CHECK((cm_sav[{1, 0}] == 4));
-    CHECK((cm_sav[{4, 2}] == 15));
+    EXPECT_TRUE((cm_sav[{0, 0}] == 1));
+    EXPECT_TRUE((cm_sav[{0, 1}] == 2));
+    EXPECT_TRUE((cm_sav[{1, 0}] == 4));
+    EXPECT_TRUE((cm_sav[{4, 2}] == 15));
 
     // Slice
     strided_span<int, 1> cm_sl = cm_sav[3];
 
-    CHECK(cm_sl[0] == 10);
-    CHECK(cm_sl[1] == 11);
-    CHECK(cm_sl[2] == 12);
+    EXPECT_TRUE(cm_sl[0] == 10);
+    EXPECT_TRUE(cm_sl[1] == 11);
+    EXPECT_TRUE(cm_sl[2] == 12);
 
     // Section
     strided_span<int, 2> cm_sec = cm_sav.section({2, 1}, {3, 2});
 
-    CHECK((cm_sec.bounds().index_bounds() == multi_span_index<2>{3, 2}));
-    CHECK((cm_sec[{0, 0}] == 8));
-    CHECK((cm_sec[{0, 1}] == 9));
-    CHECK((cm_sec[{1, 0}] == 11));
-    CHECK((cm_sec[{2, 1}] == 15));
+    EXPECT_TRUE((cm_sec.bounds().index_bounds() == multi_span_index<2>{3, 2}));
+    EXPECT_TRUE((cm_sec[{0, 0}] == 8));
+    EXPECT_TRUE((cm_sec[{0, 1}] == 9));
+    EXPECT_TRUE((cm_sec[{1, 0}] == 11));
+    EXPECT_TRUE((cm_sec[{2, 1}] == 15));
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("strided_span_bounds")
+TEST(strided_span_tests, strided_span_bounds)
 {
     int arr[] = {0, 1, 2, 3};
     multi_span<int> av(arr);
 
+    std::set_terminate([] {
+        std::cerr << "Expected Death. strided_span_bounds";
+        std::abort();
+    });
+
     {
         // incorrect sections
 
-        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);
+        EXPECT_DEATH(av.section(0, 0)[0], deathstring);
+        EXPECT_DEATH(av.section(1, 0)[0], deathstring);
+        EXPECT_DEATH(av.section(1, 1)[1], deathstring);
 
-        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);
+        EXPECT_DEATH(av.section(2, 5), deathstring);
+        EXPECT_DEATH(av.section(5, 2), deathstring);
+        EXPECT_DEATH(av.section(5, 0), deathstring);
+        EXPECT_DEATH(av.section(0, 5), deathstring);
+        EXPECT_DEATH(av.section(5, 5), deathstring);
     }
 
     {
         // zero stride
         strided_span<int, 1> sav{av, {{4}, {}}};
-        CHECK(sav[0] == 0);
-        CHECK(sav[3] == 0);
-        CHECK_THROWS_AS(sav[4], fail_fast);
+        EXPECT_TRUE(sav[0] == 0);
+        EXPECT_TRUE(sav[3] == 0);
+        EXPECT_DEATH(sav[4], deathstring);
     }
 
     {
         // zero extent
         strided_span<int, 1> sav{av, {{}, {1}}};
-        CHECK_THROWS_AS(sav[0], fail_fast);
+        EXPECT_DEATH(sav[0], deathstring);
     }
 
     {
         // zero extent and stride
         strided_span<int, 1> sav{av, {{}, {}}};
-        CHECK_THROWS_AS(sav[0], fail_fast);
+        EXPECT_DEATH(sav[0], deathstring);
     }
 
     {
         // strided array ctor with matching strided bounds
         strided_span<int, 1> sav{arr, {4, 1}};
-        CHECK(sav.bounds().index_bounds() == multi_span_index<1>{4});
-        CHECK(sav[3] == 3);
-        CHECK_THROWS_AS(sav[4], fail_fast);
+        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{4});
+        EXPECT_TRUE(sav[3] == 3);
+        EXPECT_DEATH(sav[4], deathstring);
     }
 
     {
         // strided array ctor with smaller strided bounds
         strided_span<int, 1> sav{arr, {2, 1}};
-        CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
-        CHECK(sav[1] == 1);
-        CHECK_THROWS_AS(sav[2], fail_fast);
+        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav[1] == 1);
+        EXPECT_DEATH(sav[2], deathstring);
     }
 
     {
         // strided array ctor with fitting irregular bounds
         strided_span<int, 1> sav{arr, {2, 3}};
-        CHECK(sav.bounds().index_bounds() == multi_span_index<1>{2});
-        CHECK(sav[0] == 0);
-        CHECK(sav[1] == 3);
-        CHECK_THROWS_AS(sav[2], fail_fast);
+        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
+        EXPECT_TRUE(sav[0] == 0);
+        EXPECT_TRUE(sav[1] == 3);
+        EXPECT_DEATH(sav[2], deathstring);
     }
 
     {
         // bounds cross data boundaries - from static arrays
-        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);
+        EXPECT_DEATH((strided_span<int, 1>{arr, {3, 2}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{arr, {3, 3}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{arr, {4, 5}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{arr, {5, 1}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{arr, {5, 5}}), deathstring);
     }
 
     {
         // bounds cross data boundaries - from array view
-        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);
+        EXPECT_DEATH((strided_span<int, 1>{av, {3, 2}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av, {3, 3}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av, {4, 5}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av, {5, 1}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av, {5, 5}}), deathstring);
     }
 
     {
         // bounds cross data boundaries - from dynamic arrays
-        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);
+        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {3, 2}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {3, 3}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {4, 5}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {5, 1}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {5, 5}}), deathstring);
+        EXPECT_DEATH((strided_span<int, 1>{av.data(), 2, {2, 2}}), deathstring);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
@@ -458,12 +513,16 @@ TEST_CASE("strided_span_bounds")
 #endif
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("strided_span_type_conversion")
+TEST(strided_span_tests, strided_span_type_conversion)
 {
     int arr[] = {0, 1, 2, 3};
     multi_span<int> av(arr);
 
+    std::set_terminate([] {
+        std::cerr << "Expected Death. strided_span_type_conversion";
+        std::abort();
+    });
+
     {
         strided_span<int, 1> sav{av.data(), av.size(), {av.size() / 2, 2}};
 #ifdef CONFIRM_COMPILATION_ERRORS
@@ -484,10 +543,10 @@ TEST_CASE("strided_span_type_conversion")
         strided_bounds<2> bounds{{2, bytes.size() / 4}, {bytes.size() / 2, 1}};
         strided_span<const byte, 2> sav2{bytes.data(), bytes.size(), bounds};
         strided_span<const int, 2> sav3 = sav2.as_strided_span<const int>();
-        CHECK(sav3[0][0] == 0);
-        CHECK(sav3[1][0] == 2);
-        CHECK_THROWS_AS(sav3[1][1], fail_fast);
-        CHECK_THROWS_AS(sav3[0][1], fail_fast);
+        EXPECT_TRUE(sav3[0][0] == 0);
+        EXPECT_TRUE(sav3[1][0] == 2);
+        EXPECT_DEATH(sav3[1][1], deathstring);
+        EXPECT_DEATH(sav3[0][1], deathstring);
     }
 
     // retype strided array with regular strides - from multi_span
@@ -497,10 +556,10 @@ TEST_CASE("strided_span_type_conversion")
             as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
         strided_span<const byte, 2> sav2{bytes2, bounds};
         strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
-        CHECK(sav3[0][0] == 0);
-        CHECK(sav3[1][0] == 2);
-        CHECK_THROWS_AS(sav3[1][1], fail_fast);
-        CHECK_THROWS_AS(sav3[0][1], fail_fast);
+        EXPECT_TRUE(sav3[0][0] == 0);
+        EXPECT_TRUE(sav3[1][0] == 2);
+        EXPECT_DEATH(sav3[1][1], deathstring);
+        EXPECT_DEATH(sav3[0][1], deathstring);
     }
 
     // retype strided array with not enough elements - last dimension of the array is too small
@@ -509,7 +568,7 @@ TEST_CASE("strided_span_type_conversion")
         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_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
+        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
     }
 
     // retype strided array with not enough elements - strides are too small
@@ -518,7 +577,7 @@ TEST_CASE("strided_span_type_conversion")
         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_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
+        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
     }
 
     // retype strided array with not enough elements - last dimension does not divide by the new
@@ -528,7 +587,7 @@ TEST_CASE("strided_span_type_conversion")
         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_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
+        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
     }
 
     // retype strided array with not enough elements - strides does not divide by the new
@@ -538,88 +597,63 @@ TEST_CASE("strided_span_type_conversion")
         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_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
+        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
     }
 
     // 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_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
+        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
     }
 
     // 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_THROWS_AS(sav2.as_strided_span<int>(), fail_fast);
+        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
     }
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-TEST_CASE("empty_strided_spans")
+TEST(strided_span_tests, empty_strided_spans)
 {
+    std::set_terminate([] {
+        std::cerr << "Expected Death. empty_strided_spans";
+        std::abort();
+    });
+
     {
         multi_span<int, 0> empty_av(nullptr);
         strided_span<int, 1> empty_sav{empty_av, {0, 1}};
 
-        CHECK(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
-        CHECK(empty_sav.empty());
-        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);
+        EXPECT_TRUE(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
+        EXPECT_TRUE(empty_sav.empty());
+        EXPECT_DEATH(empty_sav[0], deathstring);
+        EXPECT_DEATH(empty_sav.begin()[0], deathstring);
+        EXPECT_DEATH(empty_sav.cbegin()[0], deathstring);
 
         for (const auto& v : empty_sav) {
             (void) v;
-            CHECK(false);
+            EXPECT_TRUE(false);
         }
     }
 
     {
         strided_span<int, 1> empty_sav{nullptr, 0, {0, 1}};
 
-        CHECK(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
-        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);
+        EXPECT_TRUE(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
+        EXPECT_DEATH(empty_sav[0], deathstring);
+        EXPECT_DEATH(empty_sav.begin()[0], deathstring);
+        EXPECT_DEATH(empty_sav.cbegin()[0], deathstring);
 
         for (const auto& v : empty_sav) {
             (void) v;
-            CHECK(false);
+            EXPECT_TRUE(false);
         }
     }
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-void iterate_every_other_element(multi_span<int, dynamic_range> av)
-{
-    // pick every other element
-
-    auto length = av.size() / 2;
-#if _MSC_VER > 1800
-    auto bounds = strided_bounds<1>({length}, {2});
-#else
-    auto bounds = strided_bounds<1>(multi_span_index<1>{length}, multi_span_index<1>{2});
-#endif
-    strided_span<int, 1> strided(&av.data()[1], av.size() - 1, bounds);
-
-    CHECK(strided.size() == length);
-    CHECK(strided.bounds().index_bounds()[0] == length);
-    for (auto i = 0; i < strided.size(); ++i) {
-        CHECK(strided[i] == av[2 * i + 1]);
-    }
-
-    int idx = 0;
-    for (auto num : strided) {
-        CHECK(num == av[2 * idx + 1]);
-        idx++;
-    }
-}
-
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("strided_span_section_iteration")
+TEST(strided_span_tests, strided_span_section_iteration)
 {
     int arr[8] = {4, 0, 5, 1, 6, 2, 7, 3};
 
@@ -636,12 +670,7 @@ TEST_CASE("strided_span_section_iteration")
     }
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.11) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.3) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.5) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-TEST_CASE("dynamic_strided_span_section_iteration")
+TEST(strided_span_tests, dynamic_strided_span_section_iteration)
 {
     auto arr = new int[8];
     for (int i = 0; i < 4; ++i) {
@@ -655,39 +684,7 @@ TEST_CASE("dynamic_strided_span_section_iteration")
     delete[] arr;
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute // TODO: does not work
-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});
-
-    for (auto i = 0; i < section.extent<0>(); ++i) {
-        for (auto j = 0; j < section.extent<1>(); ++j)
-            for (auto k = 0; k < section.extent<2>(); ++k) {
-                auto idx = multi_span_index<3>{i, j, k}; // avoid braces in the CHECK macro
-                CHECK(section[idx] == expected[2 * i + 2 * j + k]);
-            }
-    }
-
-    for (auto i = 0; i < section.extent<0>(); ++i) {
-        for (auto j = 0; j < section.extent<1>(); ++j)
-            for (auto k = 0; k < section.extent<2>(); ++k)
-                CHECK(section[i][j][k] == expected[2 * i + 2 * j + k]);
-    }
-
-    int i = 0;
-    for (const auto num : section) {
-        CHECK(num == expected[i]);
-        i++;
-    }
-}
-
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("strided_span_section_iteration_3d")
+TEST(strided_span_tests, strided_span_section_iteration_3d)
 {
     int arr[3][4][2]{};
     for (auto i = 0; i < 3; ++i) {
@@ -701,12 +698,7 @@ TEST_CASE("strided_span_section_iteration_3d")
     }
 }
 
-GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.3) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.5) // NO-FORMAT: attribute
-GSL_SUPPRESS(r.11) // NO-FORMAT: attribute
-TEST_CASE("dynamic_strided_span_section_iteration_3d")
+TEST(strided_span_tests, dynamic_strided_span_section_iteration_3d)
 {
     const auto height = 12, width = 2;
     const auto size = height * width;
@@ -738,11 +730,13 @@ TEST_CASE("dynamic_strided_span_section_iteration_3d")
     delete[] arr;
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-TEST_CASE("strided_span_conversion")
+TEST(strided_span_tests, strided_span_conversion)
 {
+    std::set_terminate([] {
+        std::cerr << "Expected Death. strided_span_conversion";
+        std::abort();
+    });
+
     // get an multi_span of 'c' values from the list of X's
 
     struct X
@@ -761,8 +755,8 @@ TEST_CASE("strided_span_conversion")
     // convert to 4x12 array of bytes
     auto av = as_multi_span(as_bytes(as_multi_span(&arr[0], 4)), dim(d1), dim(d2));
 
-    CHECK(av.bounds().index_bounds()[0] == 4);
-    CHECK(av.bounds().index_bounds()[1] == 12);
+    EXPECT_TRUE(av.bounds().index_bounds()[0] == 4);
+    EXPECT_TRUE(av.bounds().index_bounds()[1] == 12);
 
     // get the last 4 columns
     auto section = av.section({0, 2 * s}, {4, s}); // { { arr[0].c[0], arr[0].c[1], arr[0].c[2],
@@ -772,8 +766,8 @@ TEST_CASE("strided_span_conversion")
     // convert to array 4x1 array of integers
     auto cs = section.as_strided_span<int>(); // { { arr[0].c }, {arr[1].c } , ... }
 
-    CHECK(cs.bounds().index_bounds()[0] == 4);
-    CHECK(cs.bounds().index_bounds()[1] == 1);
+    EXPECT_TRUE(cs.bounds().index_bounds()[0] == 4);
+    EXPECT_TRUE(cs.bounds().index_bounds()[1] == 1);
 
     // transpose to 1x4 array
     strided_bounds<2> reverse_bounds{
@@ -785,12 +779,12 @@ TEST_CASE("strided_span_conversion")
     // slice to get a one-dimensional array of c's
     strided_span<int, 1> result = transposed[0];
 
-    CHECK(result.bounds().index_bounds()[0] == 4);
-    CHECK_THROWS_AS(result.bounds().index_bounds()[1], fail_fast);
+    EXPECT_TRUE(result.bounds().index_bounds()[0] == 4);
+    EXPECT_DEATH(result.bounds().index_bounds()[1], deathstring);
 
     int i = 0;
     for (auto& num : result) {
-        CHECK(num == arr[i].c);
+        EXPECT_TRUE(num == arr[i].c);
         i++;
     }
 }

tests/test.cpp

@@ -1,26 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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
-
-#ifdef _MSC_VER
-
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26401 26409 26415 26418 26426 26429 26432 26433 26434 26435 26436 26439 26440 26443 26444 26446 26447 26451 26460 26461 26466 26472 26481 26482 26485 26492 26493 26494 26495 26496 26497) // from catch
-#endif // _MSC_VER
-
-#include <catch/catch.hpp>

tests/utils_tests.cpp

@@ -14,14 +14,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef _MSC_VER
-// blanket turn off warnings from CppCoreCheck from catch
-// so people aren't annoyed by them when running the tool.
-#pragma warning(disable : 26440 26426) // from catch
-
-#endif
-
-#include <catch/catch.hpp> // for AssertionHandler, StringRef, CHECK, TEST_...
+#include <gtest/gtest.h>
 
 #include <gsl/gsl_util> // for narrow, finally, narrow_cast, narrowing_e...
 
@@ -30,100 +23,107 @@
 #include <limits>      // for numeric_limits
 #include <stdint.h>    // for uint32_t, int32_t
 #include <type_traits> // for is_same
+#include <cstddef>     // for std::ptrdiff_t
 
 using namespace gsl;
 
-TEST_CASE("sanity check for gsl::index typedef")
+namespace
+{
+void f(int& i) { i += 1; }
+static int j = 0;
+void g() { j += 1; }
+}
+
+
+TEST(utils_tests, sanity_check_for_gsl_index_typedef)
 {
     static_assert(std::is_same<gsl::index, std::ptrdiff_t>::value,
                   "gsl::index represents wrong arithmetic type");
 }
 
-void f(int& i) { i += 1; }
-
-TEST_CASE("finally_lambda")
+TEST(utils_tests, finally_lambda)
 {
     int i = 0;
     {
         auto _ = finally([&]() { f(i); });
-        CHECK(i == 0);
+        EXPECT_TRUE(i == 0);
     }
-    CHECK(i == 1);
+    EXPECT_TRUE(i == 1);
 }
 
-TEST_CASE("finally_lambda_move")
+TEST(utils_tests, finally_lambda_move)
 {
     int i = 0;
     {
         auto _1 = finally([&]() { f(i); });
         {
             auto _2 = std::move(_1);
-            CHECK(i == 0);
+            EXPECT_TRUE(i == 0);
         }
-        CHECK(i == 1);
+        EXPECT_TRUE(i == 1);
         {
             auto _2 = std::move(_1);
-            CHECK(i == 1);
+            EXPECT_TRUE(i == 1);
         }
-        CHECK(i == 1);
+        EXPECT_TRUE(i == 1);
     }
-    CHECK(i == 1);
+    EXPECT_TRUE(i == 1);
 }
 
-TEST_CASE("finally_function_with_bind")
+TEST(utils_tests, finally_function_with_bind)
 {
     int i = 0;
     {
         auto _ = finally(std::bind(&f, std::ref(i)));
-        CHECK(i == 0);
+        EXPECT_TRUE(i == 0);
     }
-    CHECK(i == 1);
+    EXPECT_TRUE(i == 1);
 }
 
-int j = 0;
-void g() { j += 1; }
-TEST_CASE("finally_function_ptr")
+TEST(utils_tests, finally_function_ptr)
 {
     j = 0;
     {
         auto _ = finally(&g);
-        CHECK(j == 0);
+        EXPECT_TRUE(j == 0);
     }
-    CHECK(j == 1);
+    EXPECT_TRUE(j == 1);
 }
 
-GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
-TEST_CASE("narrow_cast")
+TEST(utils_tests, narrow_cast)
 {
     int n = 120;
     char c = narrow_cast<char>(n);
-    CHECK(c == 120);
+    EXPECT_TRUE(c == 120);
 
     n = 300;
     unsigned char uc = narrow_cast<unsigned char>(n);
-    CHECK(uc == 44);
+    EXPECT_TRUE(uc == 44);
 }
 
-GSL_SUPPRESS(con.5) // NO-FORMAT: attribute
-TEST_CASE("narrow")
+TEST(utils_tests, narrow)
 {
     int n = 120;
     const char c = narrow<char>(n);
-    CHECK(c == 120);
+    EXPECT_TRUE(c == 120);
 
     n = 300;
-    CHECK_THROWS_AS(narrow<char>(n), narrowing_error);
+    EXPECT_THROW(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();
 
-    CHECK(narrow<uint32_t>(int32_t(0)) == 0);
-    CHECK(narrow<uint32_t>(int32_t(1)) == 1);
-    CHECK(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
+    EXPECT_TRUE(narrow<uint32_t>(int32_t(0)) == 0);
+    EXPECT_TRUE(narrow<uint32_t>(int32_t(1)) == 1);
+    EXPECT_TRUE(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
 
-    CHECK_THROWS_AS(narrow<uint32_t>(int32_t(-1)), narrowing_error);
-    CHECK_THROWS_AS(narrow<uint32_t>(int32_min), narrowing_error);
+    EXPECT_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
+    EXPECT_THROW(narrow<uint32_t>(int32_min), narrowing_error);
 
     n = -42;
-    CHECK_THROWS_AS(narrow<unsigned>(n), narrowing_error);
+    EXPECT_THROW(narrow<unsigned>(n), narrowing_error);
+
+#if GSL_CONSTEXPR_NARROW
+    static_assert(narrow<char>(120) == 120, "Fix GSL_CONSTEXPR_NARROW");
+#endif
 }