Fixed wrong version number in exported CMake configs. (#1027)

Bump clang and Xcode supported versions and add support for VS with LLVM

.github/workflows/android.yml

@@ -0,0 +1,50 @@
+name: CI_Android
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  Android:
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - name: Start emulator
+        run: |
+          echo "y" | $ANDROID_HOME/tools/bin/sdkmanager --install 'system-images;android-24;default;x86_64'
+          echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-24;default;x86_64' --force
+          $ANDROID_HOME/emulator/emulator -list-avds
+          echo "Starting emulator"
+          # Start emulator in background
+          nohup $ANDROID_HOME/emulator/emulator -avd xamarin_android_emulator -no-snapshot > /dev/null 2>&1 &
+          echo "Emulator starting"
+
+      - name: Configure
+        run: cmake -Werror=dev -DCMAKE_TOOLCHAIN_FILE=$ANDROID_HOME/ndk-bundle/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=16 -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Debug ..
+
+      - name: Build
+        run: cmake --build . --parallel
+
+      - name: Wait for emulator ready
+        run: |
+          $ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed | tr -d '\r') ]]; do sleep 10; done; input keyevent 82'
+          $ANDROID_HOME/platform-tools/adb devices
+          $ANDROID_HOME/platform-tools/adb shell getprop ro.product.cpu.abi
+          echo "Emulator started"
+
+      - name: Deploy tests
+        run: |
+          adb push tests /data/local/tmp
+          adb shell find /data/local/tmp/tests -maxdepth 1 -exec chmod +x {} \\\;
+
+      - name: Test
+        run: adb shell find /data/local/tmp/tests -name "*_tests" -maxdepth 1 -exec {} \\\;

.github/workflows/ios.yml

@@ -0,0 +1,52 @@
+name: CI_iOS
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  iOS:
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - name: Configure
+        run: |
+          cmake \
+            -Werror=dev \
+            -GXcode \
+            -DCMAKE_SYSTEM_NAME=iOS \
+            "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
+            -DCMAKE_OSX_DEPLOYMENT_TARGET=9 \
+            -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
+            "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
+            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.1.0 \
+            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.1.0 \
+            ..
+
+      - name: Build
+        run: cmake --build . --parallel `sysctl -n hw.ncpu` --config Release -- -sdk iphonesimulator
+
+      - name: Start simulator
+        run: |
+          RUNTIME=`xcrun simctl list runtimes iOS -j|jq '.runtimes|last.identifier'`
+          UDID=`xcrun simctl list devices iPhone available -j|jq -r ".devices[$RUNTIME]|last.udid"`
+          xcrun simctl bootstatus $UDID -b
+
+      - name: Test
+        run: |
+          for TEST in `find tests/Release-iphonesimulator -depth 1 -name "*.app"`
+          do
+            xcrun simctl install booted $TEST
+            TEST_ID=`plutil -convert json -o - $TEST/Info.plist|jq -r ".CFBundleIdentifier"`
+            xcrun simctl launch --console booted $TEST_ID
+            xcrun simctl uninstall booted $TEST_ID
+          done

.travis.yml

@@ -1,551 +0,0 @@
-
-language: cpp
-notifications:
-  email: false
-
-# Use Linux unless specified otherwise
-os: linux
-dist: bionic
-
-cache:
-  directories:
-    - ${TRAVIS_BUILD_DIR}/deps
-
-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:
-
-    ##########################################################################
-    # Validate CMake configuration
-    ##########################################################################
-
-    - 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
-    - name: AppleClang Xcode-8.3 C++14 Release
-      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      os: osx
-      osx_image: xcode8.3
-
-    # 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 # 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
-
-    # Xcode 9.4
-    - name: AppleClang Xcode-9.4 C++14 Debug
-      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
-      os: osx
-      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
-    - 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
-    - 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
-    - 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
-    - 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
-    - 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
-    - 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
-    - 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
-    - name: Clang-3.9 C++14 Release
-      env: CXX=clang++-3.9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *clang39
-
-    # Clang 4.0
-    - 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
-    - name: Clang-4.0 C++14 Release
-      env: CXX=clang++-4.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *clang40
-
-    # Clang 5.0
-    - 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
-    - name: Clang-5.0 C++14 Release
-      env: CXX=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *clang50
-    - name: Clang-5.0 C++17 Debug
-      env: CXX=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
-      addons: *clang50
-    - name: Clang 5.0 C++17 Release
-      env: CXX=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
-      addons: *clang50
-
-    # Clang 6.0
-    - 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
-    - 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:
-          - 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
-
-    # 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 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 (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
-    - name: GCC-6 C++14 Debug
-      env: CXX=g++-6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
-      addons: &gcc6
-        apt:
-          packages: g++-6
-    - name: GCC-6 C++14 Release
-      env: CXX=g++-6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
-      addons: *gcc6
-
-    # 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:
-          sources:
-          - 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
-
-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:
-  ############################################################################
-  # Install a different CMake version (or several)
-  ############################################################################
-  - |
-    # 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
-
-  ############################################################################
-  # [linux]: Install the right version of libc++
-  # Based on https://github.com/ldionne/hana/blob/master/.travis.yml
-  ############################################################################
-  - |
-    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   [[ "${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";
-      elif [[ "${CXX}" == "clang++-3.9" ]]; then LLVM_VERSION="3.9.1";
-      fi
-      LLVM_URL="http://llvm.org/releases/${LLVM_VERSION}/llvm-${LLVM_VERSION}.src.tar.xz"
-      LIBCXX_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxx-${LLVM_VERSION}.src.tar.xz"
-      LIBCXXABI_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxxabi-${LLVM_VERSION}.src.tar.xz"
-      mkdir -p llvm llvm/build llvm/projects/libcxx llvm/projects/libcxxabi
-      travis_retry wget -O - ${LLVM_URL} | tar --strip-components=1 -xJ -C llvm
-      travis_retry wget -O - ${LIBCXX_URL} | tar --strip-components=1 -xJ -C llvm/projects/libcxx
-      travis_retry wget -O - ${LIBCXXABI_URL} | tar --strip-components=1 -xJ -C llvm/projects/libcxxabi
-      (cd llvm/build && cmake .. -DCMAKE_INSTALL_PREFIX=${LLVM_INSTALL})
-      (cd llvm/build/projects/libcxx && make install -j2)
-      (cd llvm/build/projects/libcxxabi && make install -j2)
-      export CXXFLAGS="-isystem ${LLVM_INSTALL}/include/c++/v1"
-      export LDFLAGS="-L ${LLVM_INSTALL}/lib -l c++ -l c++abi"
-      export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${LLVM_INSTALL}/lib"
-    fi
-
-before_script:
-  - |
-    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,103 +1,61 @@
 cmake_minimum_required(VERSION 3.1.3...3.16)
 
-project(GSL CXX)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+include(guidelineSupportLibrary)
 
-include(ExternalProject)
-find_package(Git)
+project(GSL
+    VERSION 4.0.0
+    LANGUAGES CXX
+)
 
-# Use GNUInstallDirs to provide the right locations on all platforms
+# Must include after the project call due to GNUInstallDirs requiring a language be enabled (IE. CXX)
 include(GNUInstallDirs)
 
-# creates a library GSL which is an interface (header files only)
+# Creates a library GSL which is an interface (header files only)
 add_library(GSL INTERFACE)
 
-# determine whether this is a standalone project or included by other projects
-set(GSL_STANDALONE_PROJECT OFF)
-if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-  set(GSL_STANDALONE_PROJECT ON)
-endif ()
-
-set(GSL_CXX_STANDARD "14" CACHE STRING "Use c++ standard")
-set(GSL_CXX_STD "cxx_std_${GSL_CXX_STANDARD}")
-
-if (MSVC)
-    set(GSL_CXX_STD_OPT "-std:c++${GSL_CXX_STANDARD}")
-else()
-    set(GSL_CXX_STD_OPT "-std=c++${GSL_CXX_STANDARD}")
-endif()
-
-# when minimum version required is 3.8.0 remove if below
-# both branches do exactly the same thing
-if (CMAKE_VERSION VERSION_LESS 3.7.9)
-    include(CheckCXXCompilerFlag)
-    CHECK_CXX_COMPILER_FLAG("${GSL_CXX_STD_OPT}" COMPILER_SUPPORTS_CXX_STANDARD)
-
-    if(COMPILER_SUPPORTS_CXX_STANDARD)
-        target_compile_options(GSL INTERFACE "${GSL_CXX_STD_OPT}")
-    else()
-        message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no c++${GSL_CXX_STANDARD} support. Please use a different C++ compiler.")
-    endif()
-else ()
-    target_compile_features(GSL INTERFACE "${GSL_CXX_STD}")
-    # on *nix systems force the use of -std=c++XX instead of -std=gnu++XX (default)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-endif()
-
-# add definitions to the library and targets that consume it
-target_compile_definitions(GSL INTERFACE
-    $<$<CXX_COMPILER_ID:MSVC>:
-        # remove unnecessary warnings about unchecked iterators
-        _SCL_SECURE_NO_WARNINGS
-        # remove deprecation warnings about std::uncaught_exception() (from catch)
-        _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING
-    >
-)
-
-# add include folders to the library and targets that consume it
-# 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 VERSION_GREATER 3.7.8)
-    if (MSVC_IDE)
-        option(VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
-    else()
-        set(VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
-    endif()
-
-    # add natvis file to the library so it will automatically be loaded into Visual Studio
-    if(VS_ADD_NATIVE_VISUALIZERS)
-        target_sources(GSL INTERFACE
-            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis>
-        )
-    endif()
-endif()
-
-install(TARGETS GSL EXPORT Microsoft.GSLConfig)
-install(
-    DIRECTORY include/gsl
-    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)
-
+# NOTE: If you want to use GSL prefer to link against GSL using this alias target
+# EX:
+#   target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
+#
 # 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})
+# Determine whether this is a standalone project or included by other projects
+set(GSL_STANDALONE_PROJECT OFF)
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(GSL_STANDALONE_PROJECT ON)
+endif()
+
+### Project options
+option(GSL_INSTALL "Generate and install GSL target" ${GSL_STANDALONE_PROJECT})
+option(GSL_TEST "Build and perform GSL tests" ${GSL_STANDALONE_PROJECT})
+
+# This GSL implementation generally assumes a platform that implements C++14 support.
+set(gsl_min_cxx_standard "14")
+
+if (GSL_STANDALONE_PROJECT)
+    gsl_set_default_cxx_standard(${gsl_min_cxx_standard})
+else()
+    gsl_client_set_cxx_standard(${gsl_min_cxx_standard})
+endif()
+
+# Setup include directory
+add_subdirectory(include)
+
+# Add natvis file
+gsl_add_native_visualizer_support()
+
+# Add packaging support
+gsl_create_packaging_file()
+
+if (GSL_INSTALL)
+    # Setup install/export logic
+    gsl_install_logic()
+endif()
+
 if (GSL_TEST)
-	enable_testing()
-	add_subdirectory(tests)
-endif ()
+    enable_testing()
+    add_subdirectory(tests)
+endif()

CONTRIBUTING.md

@@ -17,7 +17,7 @@ Please submit a Contributor License Agreement (CLA) before submitting a pull req
 Your pull request should: 
 
 * Include a description of what your change intends to do
-* Be a child commit of a reasonably recent commit in the **master** branch 
+* Be a child commit of a reasonably recent commit in the **main** branch 
     * Requests need not be a single commit, but should be a linear sequence of commits (i.e. no merge commits in your PR)
 * It is desirable, but not necessary, for the tests to pass at each commit. Please see [README.md](./README.md) for instructions to build the test suite. 
 * Have clear commit messages 

GSL.natvis

@@ -19,9 +19,7 @@
         </Expand>
     </Type>
 
-    <!-- These types are from the span header. -->
-    <!-- This is for dynamic_extent spans. -->
-    <Type Name="gsl::span&lt;*, -1&gt;">
+    <Type Name="gsl::span&lt;*, *&gt;">
         <DisplayString>{{ extent = {storage_.size_} }}</DisplayString>
         <Expand>
             <ArrayItems>
@@ -31,43 +29,7 @@
         </Expand>
     </Type>
 
-    <!-- This works for constexpr size spans. -->
-    <Type Name="gsl::span&lt;*, *&gt;">
-        <DisplayString>{{ extent = {extent} }}</DisplayString>
-        <Expand>
-            <ArrayItems>
-                <Size>extent</Size>
-                <ValuePointer>storage_.data_</ValuePointer>
-            </ArrayItems>
-        </Expand>
-    </Type>
-
-    <!-- This is for dynamic_extent string_spans. -->
-    <Type Name="gsl::basic_string_span&lt;*, -1&gt;">
-        <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
-        <Expand>
-            <Item Name="[size]">span_.storage_.size_</Item>
-            <ArrayItems>
-                <Size>span_.storage_.size_</Size>
-                <ValuePointer>span_.storage_.data_</ValuePointer>
-            </ArrayItems>
-        </Expand>
-    </Type>
-
-    <!-- This works for constexpr size string_spans. -->
     <Type Name="gsl::basic_string_span&lt;*, *&gt;">
-        <DisplayString>{span_.storage_.data_,[span_.extent]na}</DisplayString>
-        <Expand>
-            <Item Name="[size]">span_.extent</Item>
-            <ArrayItems>
-                <Size>span_.extent</Size>
-                <ValuePointer>span_.storage_.data_</ValuePointer>
-            </ArrayItems>
-        </Expand>
-    </Type>
-
-    <!-- This is for dynamic_extent zstring_spans. -->
-    <Type Name="gsl::basic_zstring_span&lt;*, -1&gt;">
         <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
         <Expand>
             <Item Name="[size]">span_.storage_.size_</Item>
@@ -77,19 +39,18 @@
             </ArrayItems>
         </Expand>
     </Type>
-    
-    <!-- This works for constexpr size string_spans. -->
+
     <Type Name="gsl::basic_zstring_span&lt;*, *&gt;">
-        <DisplayString>{span_.storage_.data_,[span_.extent]na}</DisplayString>
+        <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
         <Expand>
-            <Item Name="[size]">span_.extent</Item>
+            <Item Name="[size]">span_.storage_.size_</Item>
             <ArrayItems>
-                <Size>span_.extent</Size>
+                <Size>span_.storage_.size_</Size>
                 <ValuePointer>span_.storage_.data_</ValuePointer>
             </ArrayItems>
         </Expand>
     </Type>
-    
+
     <!-- These types are from the gsl header. -->
     <Type Name="gsl::not_null&lt;*&gt;">
         <!-- We can always dereference this since it's an invariant. -->

README.md

@@ -1,12 +1,11 @@
-# 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)
+# GSL: Guidelines Support Library
+[![Build Status](https://dev.azure.com/cppstat/GSL/_apis/build/status/microsoft.GSL?branchName=main)](https://dev.azure.com/cppstat/GSL/_build/latest?definitionId=1&branchName=main)
 
 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.
 
-The library includes types like `span<T>`, `string_span`, `owner<>` and others.
-
-The entire implementation is provided inline in the headers under the [gsl](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support. There are specific workarounds to support MSVC 2015.
+The entire implementation is provided inline in the headers under the [gsl](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support.
 
 While some types have been broken out into their own headers (e.g. [gsl/span](./include/gsl/span)),
 it is simplest to just include [gsl/gsl](./include/gsl/gsl) and gain access to the entire library.
@@ -20,35 +19,104 @@ This project has adopted the [Microsoft Open Source Code of Conduct](https://ope
 # Usage of Third Party Libraries
 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.
 
+# Supported features
+## Microsoft GSL implements the following from the C++ Core Guidelines:
+
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+[**1. Views**][cg-views]           |            |
+owner                              | &#x2611;   | an alias for a raw pointer
+not_null                           | &#x2611;   | restricts a pointer / smart pointer to hold non-null values
+span                               | &#x2611;   | a view over a contiguous sequence of memory. Based on the standardized verison of `std::span`, however `gsl::span` enforces bounds checking. See the [wiki](https://github.com/microsoft/GSL/wiki/gsl::span-and-std::span) for additional information.
+span_p                             | &#x2610;   | spans a range starting from a pointer to the first place for which the predicate is true
+basic_zstring                      | &#x2611;   | A pointer to a C-string (zero-terminated array) with a templated char type
+zstring                            | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of char
+czstring                           | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of const char
+wzstring                           | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of wchar_t
+cwzstring                          | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of const wchar_t
+u16zstring                         | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of char16_t
+cu16zstring                        | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of const char16_t
+u32zstring                         | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of char32_t
+cu32zstring                        | &#x2611;   | An alias to `basic_zstring` with dynamic extent and a char type of const char32_t
+[**2. Owners**][cg-owners]         |            |
+unique_ptr                         | &#x2611;   | an alias to `std::unique_ptr`
+shared_ptr                         | &#x2611;   | an alias to `std::shared_ptr`
+stack_array                        | &#x2610;   | a stack-allocated array
+dyn_array                          | &#x2610;   | a heap-allocated array
+[**3. Assertions**][cg-assertions] |            |
+Expects                            | &#x2611;   | a precondition assertion; on failure it terminates
+Ensures                            | &#x2611;   | a postcondition assertion; on failure it terminates
+[**4. Utilities**][cg-utilities]   |            |
+move_owner                         | &#x2610;   | a helper function that moves one `owner` to the other
+byte                               | &#x2611;   | either an alias to std::byte or a byte type
+final_action                       | &#x2611;   | a RAII style class that invokes a functor on its destruction
+finally                            | &#x2611;   | a helper function instantiating `final_action`
+GSL_SUPPRESS                       | &#x2611;   | a macro that takes an argument and turns it into `[[gsl::suppress(x)]]` or `[[gsl::suppress("x")]]`
+[[implicit]]                       | &#x2610;   | a "marker" to put on single-argument constructors to explicitly make them non-explicit
+index                              | &#x2611;   | a type to use for all container and array indexing (currently an alias for std::ptrdiff_t)
+joining_thread                     | &#x2610;   | a RAII style version of `std::thread` that joins
+narrow                             | &#x2611;   | a checked version of narrow_cast; it can throw `narrowing_error`
+narrow_cast                        | &#x2611;   | a narrowing cast for values and a synonym for static_cast
+narrowing_error                    | &#x2611;   | a custom exception type thrown by `narrow()`
+[**5. Concepts**][cg-concepts]     | &#x2610;   |
+
+## The following features do not exist in or have been removed from the C++ Core Guidelines:
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+strict_not_null                    | &#x2611;   | A stricter version of `not_null` with explicit constructors
+multi_span                         | &#x2610;   | Deprecated. Multi-dimensional span.
+strided_span                       | &#x2610;   | Deprecated. Support for this type has been discontinued.
+basic_string_span                  | &#x2610;   | Deprecated. Like `span` but for strings with a templated char type
+string_span                        | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char
+cstring_span                       | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char
+wstring_span                       | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of wchar_t
+cwstring_span                      | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const wchar_t
+u16string_span                     | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char16_t
+cu16string_span                    | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char16_t
+u32string_span                     | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char32_t
+cu32string_span                    | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char32_t
+
+This is based on [CppCoreGuidelines semi-specification](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gsl-guidelines-support-library).
+
+[cg-views]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslview-views
+[cg-owners]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslowner-ownership-pointers
+[cg-assertions]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslassert-assertions
+[cg-utilities]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslutil-utilities
+[cg-concepts]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslconcept-concepts
+
 # Quick Start
-## Supported Platforms
-The test suite that exercises GSL has been built and passes successfully on the following platforms:<sup>1)</sup>
+## Supported Compilers / Toolsets
+The GSL officially supports the latest and previous major versions of VS with MSVC & LLVM, GCC, Clang, and XCode with Apple-Clang.
+Within these two major versions, we try to target the latest minor updates / revisions (although this may be affected by
+delays between a toolchain's release and when it becomes widely available for use).
+Below is a table showing the versions currently being tested.
 
-* 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-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)
-* OS X El Capitan (10.11) using Xcode with AppleClang 8.0.0.8000042
-* OS X High Sierra 10.13.2 (17C88) using Apple LLVM version 9.0.0 (clang-900.0.39.2)
-* FreeBSD 10.x with Clang/LLVM 3.6
+Compiler |Toolset Versions Currently Tested
+:------- |--:
+ XCode | 13.2.1 & 12.5.1
+ GCC | 11[^1] & 10[^2]
+ Clang | 12[^2] & 11[^2]
+ Visual Studio with MSVC | VS2022[^3] & VS2019[^4]
+ Visual Studio with LLVM | VS2022[^3] & VS2019[^4]
 
-> If you successfully port GSL to another platform, we would love to hear from you. Please submit an issue to let us know. Also please consider
-contributing any changes that were necessary back to this project to benefit the wider community.
 
-<sup>1)</sup> For `gsl::byte` to work correctly with Clang and GCC you might have to use the ` -fno-strict-aliasing` compiler option.
+[^1]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26).
+[^2]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-Readme.md#language-and-runtime).
+[^3]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/win/Windows2022-Readme.md#visual-studio-enterprise-2022).
+[^4]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/win/Windows2019-Readme.md#visual-studio-enterprise-2019).
+
+---
+If you successfully port GSL to another platform, we would love to hear from you!
+- Submit an issue specifying the platform and target.
+- Consider contributing your changes by filing a pull request with any necessary changes.
+- If at all possible, add a CI/CD step and add the button to the table below!
+
+Target | CI/CD Status
+:------- | -----------:
+iOS | ![CI_iOS](https://github.com/microsoft/GSL/workflows/CI_iOS/badge.svg)
+Android | ![CI_Android](https://github.com/microsoft/GSL/workflows/CI_Android/badge.svg)
+
+Note: These CI/CD steps are run with each pull request, however failures in them are non-blocking.
 
 ## Building the tests
 To build the tests, you will require the following:
@@ -65,7 +133,7 @@ These steps assume the source code of this repository has been cloned into a dir
 
 2. Configure CMake to use the compiler of your choice (you can see a list by running `cmake --help`).
 
-        cmake -G "Visual Studio 14 2015" c:\GSL
+        cmake -G "Visual Studio 15 2017" c:\GSL
 
 3. Build the test suite (in this case, in the Debug configuration, Release is another good choice).
 
@@ -118,5 +186,36 @@ The library provides a Config file for CMake, once installed it can be found via
 Which, when successful, will add library target called `Microsoft.GSL::GSL` which you can use via the usual
 `target_link_libraries` mechanism.
 
+### FetchContent
+
+If you are using cmake version 3.11+ you can use the offical FetchContent module.
+This allows you to easily incorporate GSL into your project.
+
+```cmake
+# NOTE: This example uses cmake version 3.14 (FetchContent_MakeAvailable).
+# Since it streamlines the FetchContent process
+cmake_minimum_required(VERSION 3.14)
+
+include(FetchContent)
+
+# In this example we are picking a specific tag.
+# You can also pick a specific commit, if you need to.
+FetchContent_Declare(GSL
+    GIT_REPOSITORY "https://github.com/microsoft/GSL"
+    GIT_TAG "v3.1.0"
+)
+
+FetchContent_MakeAvailable(GSL)
+
+# Now you can link against the GSL interface library
+add_executable(foobar)
+
+# Link against the interface library (IE header only library)
+target_link_libraries(foobar PRIVATE GSL)
+```
+
 ## 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.
+
+If you are using cmake this will be done automatically for you.
+See 'GSL_VS_ADD_NATIVE_VISUALIZERS'

appveyor.yml

@@ -1,128 +0,0 @@
-shallow_clone: true
-
-platform:
-  - x86
-  - x64
-
-configuration:
-  - Debug
-  - Release
-
-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.14.4-win32-x86
-  - C:\Tools\ninja
-
-install:
-  - ps: |
-      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"
-      }
-
-before_build:
-  - ps: |
-      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 {
-        $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: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";
-        }
-      }
-      $env:CMakeBuildFlags = "--config $env:CONFIGURATION -- $GeneratorFlags"
-  - mkdir build
-  - cd build
-  - if %USE_GENERATOR%==Ninja (call %VCVARSALL%)
-  - echo %CMakeGenFlags%
-  - cmake .. %CMakeGenFlags%
-
-build_script:
-  - echo %CMakeBuildFlags%
-  - cmake --build . %CMakeBuildFlags%
-
-test_script:
-  - ctest -j2
-
-deploy: off

azure-pipelines.yml

@@ -0,0 +1,66 @@
+trigger:
+  - main
+
+pr:
+  autoCancel: true
+
+stages:
+- stage: GCC
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: gcc
+      image: ubuntu-20.04
+      compilerVersions: [ 11, 10 ]
+      setupfile: 'setup_gcc.yml'
+
+- stage: Clang
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: clang
+      image: ubuntu-20.04
+      compilerVersions: [ 12, 11 ]
+      setupfile: 'setup_clang.yml'
+
+- stage: Xcode
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'Xcode'
+      image: macOS-11
+      compilerVersions: [ '12.5.1', '13.2.1' ]
+      setupfile: 'setup_apple.yml'
+
+- stage: VS_MSVC
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2019 (MSVC)'
+      compilerVersions: [ 'default' ]
+      image: windows-2019
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2022 (MSVC)'
+      compilerVersions: [ 'default' ]
+      image: windows-2022
+
+- stage: VS_LLVM
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2019 (LLVM)'
+      compilerVersions: [ 'default' ]
+      image: windows-2019
+      extraCmakeArgs: '-T ClangCL'
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2022 (LLVM)'
+      compilerVersions: [ 'default' ]
+      image: windows-2022
+      extraCmakeArgs: '-T ClangCL'

cmake/guidelineSupportLibrary.cmake

@@ -0,0 +1,116 @@
+# This cmake module is meant to hold helper functions/macros
+# that make maintaining the cmake build system much easier.
+# This is especially helpful since gsl needs to provide coverage
+# for multiple versions of cmake.
+#
+# Any functions/macros should have a gsl_* prefix to avoid problems
+if (CMAKE_VERSION VERSION_GREATER 3.10 OR CMAKE_VERSION VERSION_EQUAL 3.10)
+    include_guard()
+else()
+    if (DEFINED guideline_support_library_include_guard)
+        return()
+    endif()
+    set(guideline_support_library_include_guard ON)
+endif()
+
+# Necessary for 'write_basic_package_version_file'
+include(CMakePackageConfigHelpers)
+
+function(gsl_set_default_cxx_standard min_cxx_standard)
+    set(GSL_CXX_STANDARD "${min_cxx_standard}" CACHE STRING "Use c++ standard")
+
+    set(GSL_CXX_STD "cxx_std_${GSL_CXX_STANDARD}")
+
+    if (MSVC)
+        set(GSL_CXX_STD_OPT "-std:c++${GSL_CXX_STANDARD}")
+    else()
+        set(GSL_CXX_STD_OPT "-std=c++${GSL_CXX_STANDARD}")
+    endif()
+
+    # when minimum version required is 3.8.0 remove if below
+    # both branches do exactly the same thing
+    if (CMAKE_VERSION VERSION_LESS 3.7.9)
+        include(CheckCXXCompilerFlag)
+        CHECK_CXX_COMPILER_FLAG("${GSL_CXX_STD_OPT}" COMPILER_SUPPORTS_CXX_STANDARD)
+
+        if(COMPILER_SUPPORTS_CXX_STANDARD)
+            target_compile_options(GSL INTERFACE "${GSL_CXX_STD_OPT}")
+        else()
+            message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no c++${GSL_CXX_STANDARD} support. Please use a different C++ compiler.")
+        endif()
+    else()
+        target_compile_features(GSL INTERFACE "${GSL_CXX_STD}")
+        # on *nix systems force the use of -std=c++XX instead of -std=gnu++XX (default)
+        set(CMAKE_CXX_EXTENSIONS OFF)
+    endif()
+endfunction()
+
+# The best way for a project to specify the GSL's C++ standard is by the client specifying
+# the CMAKE_CXX_STANDARD. However, this isn't always ideal. Since the CMAKE_CXX_STANDARD is
+# tied to the cmake version. And many projects have low cmake minimums.
+#
+# So provide an alternative approach in case that doesn't work.
+function(gsl_client_set_cxx_standard min_cxx_standard)
+    if (DEFINED CMAKE_CXX_STANDARD)
+        if (${CMAKE_CXX_STANDARD} VERSION_LESS ${min_cxx_standard})
+            message(FATAL_ERROR "GSL: Requires at least CXX standard ${min_cxx_standard}, user provided ${CMAKE_CXX_STANDARD}")
+        endif()
+
+        # Set the GSL standard to what the client desires
+        set(GSL_CXX_STANDARD "${CMAKE_CXX_STANDARD}" PARENT_SCOPE)
+
+        # Exit out early to avoid extra unneccessary work
+        return()
+    endif()
+
+    # Otherwise pick a reasonable default
+    gsl_set_default_cxx_standard(${min_cxx_standard})
+endfunction()
+
+# Adding the GSL.natvis files improves the debugging experience for users of this library.
+function(gsl_add_native_visualizer_support)
+    if (CMAKE_VERSION VERSION_GREATER 3.7.8)
+        if (MSVC_IDE)
+            option(GSL_VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
+        else()
+            set(GSL_VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
+        endif()
+
+        # add natvis file to the library so it will automatically be loaded into Visual Studio
+        if(GSL_VS_ADD_NATIVE_VISUALIZERS)
+            target_sources(GSL INTERFACE $<BUILD_INTERFACE:${GSL_SOURCE_DIR}/GSL.natvis>)
+        endif()
+    endif()
+endfunction()
+
+function(gsl_install_logic)
+    install(TARGETS GSL EXPORT Microsoft.GSLConfig)
+    install(
+        DIRECTORY include/gsl
+        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)
+
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
+endfunction()
+
+# Add find_package() versioning support. The version for
+# generated Microsoft.GSLConfigVersion.cmake will be used from
+# last project() command. The version's compatibility is set between all
+# minor versions (as it was in prev. GSL releases).
+function(gsl_create_packaging_file)
+    if(${CMAKE_VERSION} VERSION_LESS "3.14.0")
+        write_basic_package_version_file(
+            ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
+            COMPATIBILITY SameMajorVersion
+        )
+    else()
+        write_basic_package_version_file(
+            ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
+            COMPATIBILITY SameMajorVersion
+            ARCH_INDEPENDENT
+        )
+    endif()
+endfunction()

include/CMakeLists.txt

@@ -0,0 +1,20 @@
+
+# Add include folders to the library and targets that consume it
+# the SYSTEM keyword suppresses warnings for users of the library
+#
+# By adding this directory as an include directory the user gets a
+# namespace effect.
+#
+# IE:
+#   #include <gsl/gsl>
+if(GSL_STANDALONE_PROJECT)
+    target_include_directories(GSL INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+else()
+    target_include_directories(GSL SYSTEM INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+endif()

include/gsl/algorithm

@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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_ALGORITHM_H
+#define GSL_ALGORITHM_H
+
+#include <gsl/assert> // for Expects
+#include <gsl/span>   // for dynamic_extent, span
+
+#include <algorithm>   // for copy_n
+#include <cstddef>     // for ptrdiff_t
+#include <type_traits> // for is_assignable
+
+#ifdef _MSC_VER
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4996) // unsafe use of std::copy_n
+
+#endif // _MSC_VER
+
+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::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,
+                  "Elements of source span can not be assigned to elements of destination span");
+    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
+                      (SrcExtent <= DestExtent),
+                  "Source range is longer than target range");
+
+    Expects(dest.size() >= src.size());
+    // clang-format off
+    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
+    // clang-format on
+    std::copy_n(src.data(), src.size(), dest.data());
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_ALGORITHM_H

include/gsl/assert

@@ -0,0 +1,136 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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_CONTRACTS_H
+#define GSL_CONTRACTS_H
+
+//
+// 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(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+#define GSL_KERNEL_MODE
+
+#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
+#include <intrin.h>
+#define RANGE_CHECKS_FAILURE 0
+
+#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))
+
+//
+// make suppress attributes parse for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#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)
+
+#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 // defined(__clang__) || defined(__GNUC__)
+
+//
+// GSL_ASSUME(cond)
+//
+// Tell the optimizer that the predicate cond must hold. It is unspecified
+// whether or not cond is actually evaluated.
+//
+#ifdef _MSC_VER
+#define GSL_ASSUME(cond) __assume(cond)
+#elif defined(__GNUC__)
+#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
+#else
+#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
+#endif
+
+//
+// GSL.assert: assertions
+//
+
+namespace gsl
+{
+
+namespace details
+{
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    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);
+    }
+
+    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
+    {
+        static terminate_handler handler = &default_terminate_handler;
+        return handler;
+    }
+
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    [[noreturn]] inline void terminate() noexcept
+    {
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+        (*gsl::details::get_terminate_handler())();
+#else
+        std::terminate();
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+    }
+
+} // namespace details
+} // namespace gsl
+
+#define GSL_CONTRACT_CHECK(type, cond)                                                             \
+    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
+
+#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/byte

@@ -0,0 +1,213 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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_BYTE_H
+#define GSL_BYTE_H
+
+//
+// make suppress attributes work for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#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)
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates
+                                 // does not always work
+
+#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) ||                                                   \
+    (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
+
+#define GSL_USE_STD_BYTE 1
+
+#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) || (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 libstdc++ actually contains std::byte
+#if defined(__cplusplus) && (__cplusplus >= 201703L) &&                                            \
+    (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603) ||                                      \
+     defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 1
+
+#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 0
+
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+#endif // GSL_USE_STD_BYTE
+
+#endif // _MSC_VER
+
+// Use __may_alias__ attribute on gcc and clang
+#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
+
+using std::byte;
+using std::to_integer;
+
+#else // GSL_USE_STD_BYTE
+
+// This is a simple definition for now that allows
+// use of byte within span<> to be standards-compliant
+enum class byte_may_alias byte : unsigned char
+{
+};
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator<<(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) >> shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) >> shift);
+}
+
+constexpr byte& operator|=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte operator|(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator&=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte operator&(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator^=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator^(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr IntegerType to_integer(byte b) noexcept
+{
+    return static_cast<IntegerType>(b);
+}
+
+#endif // GSL_USE_STD_BYTE
+
+template <bool E, typename T>
+constexpr byte to_byte_impl(T t) noexcept
+{
+    static_assert(
+        E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
+           "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
+    return static_cast<byte>(t);
+}
+template <>
+// NOTE: need suppression since c++14 does not allow "return {t}"
+// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
+constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
+{
+    return byte(t);
+}
+
+template <typename T>
+constexpr byte to_byte(T t) noexcept
+{
+    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
+}
+
+template <int I>
+constexpr byte to_byte() noexcept
+{
+    static_assert(I >= 0 && I <= 255,
+                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
+    return static_cast<byte>(I);
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_BYTE_H

include/gsl/gsl

@@ -17,13 +17,16 @@
 #ifndef GSL_GSL_H
 #define GSL_GSL_H
 
-#include <gsl/gsl_algorithm> // copy
-#include <gsl/gsl_assert>    // Ensures/Expects
-#include <gsl/gsl_byte>      // byte
-#include <gsl/gsl_util>      // finally()/narrow()/narrow_cast()...
-#include <gsl/multi_span>    // multi_span, strided_span...
-#include <gsl/pointers>      // owner, not_null
-#include <gsl/span>          // span
-#include <gsl/string_span>   // zstring, string_span, zstring_builder...
+#include <gsl/algorithm>   // copy
+#include <gsl/assert>      // Ensures/Expects
+#include <gsl/byte>        // byte
+#include <gsl/pointers>    // owner, not_null
+#include <gsl/span>        // span
+#include <gsl/string_span> // zstring, string_span, zstring_builder...
+#include <gsl/util>        // finally()/narrow_cast()...
+
+#ifdef __cpp_exceptions
+#include <gsl/narrow> // narrow()
+#endif
 
 #endif // GSL_GSL_H

include/gsl/gsl_algorithm

@@ -1,61 +1,4 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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_ALGORITHM_H
-#define GSL_ALGORITHM_H
-
-#include <gsl/gsl_assert> // for Expects
-#include <gsl/span>       // for dynamic_extent, span
-
-#include <algorithm>   // for copy_n
-#include <cstddef>     // for ptrdiff_t
-#include <type_traits> // for is_assignable
-
-#ifdef _MSC_VER
-#pragma warning(push)
-
-// turn off some warnings that are noisy about our Expects statements
-#pragma warning(disable : 4127) // conditional expression is constant
-#pragma warning(disable : 4996) // unsafe use of std::copy_n
-
-#endif // _MSC_VER
-
-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::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,
-                  "Elements of source span can not be assigned to elements of destination span");
-    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
-                      (SrcExtent <= DestExtent),
-                  "Source range is longer than target range");
-
-    Expects(dest.size() >= src.size());
-    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
-    std::copy_n(src.data(), src.size(), dest.data());
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // GSL_ALGORITHM_H
+#pragma once
+#pragma message(                                                                                   \
+    "This header will soon be removed. Use <gsl/algorithm> instead of <gsl/gsl_algorithm>")
+#include <gsl/algorithm>

include/gsl/gsl_assert

@@ -1,133 +1,3 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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_CONTRACTS_H
-#define GSL_CONTRACTS_H
-
-//
-// 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(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
-
-#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
-#include <intrin.h>
-#define RANGE_CHECKS_FAILURE 0
-
-#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))
-
-//
-// make suppress attributes parse for some compilers
-// Hopefully temporary until suppression standardization occurs
-//
-#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)
-
-#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 // defined(__clang__) || defined(__GNUC__)
-
-//
-// GSL_ASSUME(cond)
-//
-// Tell the optimizer that the predicate cond must hold. It is unspecified
-// whether or not cond is actually evaluated.
-//
-#ifdef _MSC_VER
-#define GSL_ASSUME(cond) __assume(cond)
-#elif defined(__GNUC__)
-#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
-#else
-#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
-#endif
-
-//
-// GSL.assert: assertions
-//
-
-namespace gsl
-{
-
-namespace details
-{
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-
-    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);
-    }
-
-    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
-    {
-        static terminate_handler handler = &default_terminate_handler;
-        return handler;
-    }
-
-#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-
-    [[noreturn]] inline void terminate() noexcept
-    {
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-        (*gsl::details::get_terminate_handler())();
-#else
-        std::terminate();
-#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-    }
-
-} // namespace details
-} // namespace gsl
-
-#define GSL_CONTRACT_CHECK(type, cond)                                                             \
-    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
-
-#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
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/assert> instead of <gsl/gsl_assert>")
+#include <gsl/assert>

include/gsl/gsl_byte

@@ -1,209 +1,3 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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_BYTE_H
-#define GSL_BYTE_H
-
-//
-// make suppress attributes work for some compilers
-// Hopefully temporary until suppression standardization occurs
-//
-#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__
-
-#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)
-
-// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
-#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates does not always work
-
-#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) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
-
-#define GSL_USE_STD_BYTE 1
-
-#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) || (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) && \
-  (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  || \
-   defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
-
-#define GSL_USE_STD_BYTE 1
-
-#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
-      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
-      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
-
-#define GSL_USE_STD_BYTE 0
-
-#endif //defined(__cplusplus) && (__cplusplus >= 201703L) &&
-       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
-       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
-#endif // GSL_USE_STD_BYTE
-
-#endif // _MSC_VER
-
-// Use __may_alias__ attribute on gcc and clang
-#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
-
-using std::byte;
-using std::to_integer;
-
-#else // GSL_USE_STD_BYTE
-
-// This is a simple definition for now that allows
-// use of byte within span<> to be standards-compliant
-enum class byte_may_alias byte : unsigned char
-{
-};
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
-{
-    return b = byte(static_cast<unsigned char>(b) << shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte operator<<(byte b, IntegerType shift) noexcept
-{
-    return byte(static_cast<unsigned char>(b) << shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
-{
-    return b = byte(static_cast<unsigned char>(b) >> shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte operator>>(byte b, IntegerType shift) noexcept
-{
-    return byte(static_cast<unsigned char>(b) >> shift);
-}
-
-constexpr byte& operator|=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-}
-
-constexpr byte operator|(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-}
-
-constexpr byte& operator&=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-}
-
-constexpr byte operator&(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-}
-
-constexpr byte& operator^=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-}
-
-constexpr byte operator^(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-}
-
-constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr IntegerType to_integer(byte b) noexcept
-{
-    return static_cast<IntegerType>(b);
-}
-
-#endif // GSL_USE_STD_BYTE
-
-template <bool E, typename T>
-constexpr byte to_byte_impl(T t) noexcept
-{
-    static_assert(
-        E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
-           "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
-    return static_cast<byte>(t);
-}
-template <>
-// NOTE: need suppression since c++14 does not allow "return {t}"
-// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
-constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
-{
-    return byte(t);
-}
-
-template <typename T>
-constexpr byte to_byte(T t) noexcept
-{
-    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
-}
-
-template <int I>
-constexpr byte to_byte() noexcept
-{
-    static_assert(I >= 0 && I <= 255,
-                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
-    return static_cast<byte>(I);
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // GSL_BYTE_H
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/byte> instead of <gsl/gsl_byte>")
+#include <gsl/byte>

include/gsl/gsl_narrow

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/narrow> instead of <gsl/gsl_narrow>")
+#include <gsl/narrow>

include/gsl/gsl_util

@@ -1,171 +1,3 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// 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_UTIL_H
-#define GSL_UTIL_H
-
-#include <gsl/gsl_assert> // for Expects
-
-#include <array>
-#include <cstddef>          // for ptrdiff_t, size_t
-#include <initializer_list> // for initializer_list
-#include <type_traits>      // for is_signed, integral_constant
-#include <utility>          // for exchange, forward
-
-#if defined(_MSC_VER) && !defined(__clang__)
-
-#pragma warning(push)
-#pragma warning(disable : 4127) // conditional expression is constant
-
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-#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
-{
-//
-// GSL.util: utilities
-//
-
-// index type for all container indexes/subscripts/sizes
-using index = std::ptrdiff_t;
-
-// final_action allows you to ensure something gets run at the end of a scope
-template <class F>
-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_(std::exchange(other.invoke_, false)) {}
-
-    final_action(const final_action&) = delete;
-    final_action& operator=(const final_action&) = delete;
-    final_action& operator=(final_action&&) = delete;
-
-    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // terminate if throws
-    ~final_action() noexcept
-    {
-        if (invoke_) f_();
-    }
-
-private:
-    F f_;
-    bool invoke_{true};
-};
-
-// finally() - convenience function to generate a final_action
-template <class F>
-final_action<F> finally(const F& f) noexcept
-{
-    return final_action<F>(f);
-}
-
-template <class F>
-final_action<F> finally(F&& f) noexcept
-{
-    return final_action<F>(std::forward<F>(f));
-}
-
-// narrow_cast(): a searchable way to do narrowing casts of values
-template <class T, class U>
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-constexpr T narrow_cast(U&& u) noexcept
-{
-    return static_cast<T>(std::forward<U>(u));
-}
-
-struct narrowing_error : public std::exception
-{
-};
-
-namespace details
-{
-    template <class T, class U>
-    struct is_same_signedness
-        : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
-    {
-    };
-} // namespace details
-
-// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
-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) throw narrowing_error{};
-    if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
-        throw narrowing_error{};
-    return t;
-}
-
-//
-// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
-//
-template <class T, std::size_t N>
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-constexpr T& at(T (&arr)[N], const index i)
-{
-    Expects(i >= 0 && i < narrow_cast<index>(N));
-    return arr[narrow_cast<std::size_t>(i)];
-}
-
-template <class Cont>
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
-{
-    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
-    using size_type = decltype(cont.size());
-    return cont[narrow_cast<size_type>(i)];
-}
-
-template <class T>
-GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-constexpr T at(const std::initializer_list<T> cont, const index i)
-{
-    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
-    return *(cont.begin() + i);
-}
-
-} // namespace gsl
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
-
-#pragma warning(pop)
-
-#endif // _MSC_VER
-
-#endif // GSL_UTIL_H
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/util> instead of <gsl/gsl_util>")
+#include <gsl/util>

include/gsl/narrow

@@ -0,0 +1,71 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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_NARROW_H
+#define GSL_NARROW_H
+#include <gsl/assert> // for Expects
+#include <gsl/util>   // for narrow_cast
+namespace gsl
+{
+struct narrowing_error : public std::exception
+{
+    const char* what() const noexcept override { return "narrowing_error"; }
+};
+
+// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
+template <class T, class U, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+    // clang-format on
+    constexpr T narrow(U u) noexcept(false)
+{
+    constexpr const bool is_different_signedness =
+        (std::is_signed<T>::value != std::is_signed<U>::value);
+
+GSL_SUPPRESS(es.103) // NO-FORMAT: attribute // don't overflow
+GSL_SUPPRESS(es.104) // NO-FORMAT: attribute // don't underflow
+GSL_SUPPRESS(p.2) // NO-FORMAT: attribute // don't rely on undefined behavior
+    const T t = narrow_cast<T>(u); // While this is technically undefined behavior in some cases (i.e., if the source value is of floating-point type
+                                   // and cannot fit into the destination integral type), the resultant behavior is benign on the platforms
+                                   // that we target (i.e., no hardware trap representations are hit).
+
+    if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{}))))
+    {
+        throw narrowing_error{};
+    }
+
+    return t;
+}
+
+template <class T, class U, typename std::enable_if<!std::is_arithmetic<T>::value>::type* = nullptr>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+    // clang-format on
+    constexpr T narrow(U u) noexcept(false)
+{
+    const T t = narrow_cast<T>(u);
+
+    if (static_cast<U>(t) != u)
+    {
+        throw narrowing_error{};
+    }
+
+    return t;
+}
+} // namespace gsl
+#endif // GSL_NARROW_H

include/gsl/pointers

@@ -17,33 +17,48 @@
 #ifndef GSL_POINTERS_H
 #define GSL_POINTERS_H
 
-#include <gsl/gsl_assert>  // for Ensures, Expects
+#include <gsl/assert> // for Ensures, Expects
 
 #include <algorithm>    // for forward
-#include <iosfwd>       // for ptrdiff_t, nullptr_t, ostream, size_t
+#include <cstddef>      // for ptrdiff_t, nullptr_t, size_t
 #include <memory>       // for shared_ptr, unique_ptr
 #include <system_error> // for hash
 #include <type_traits>  // for enable_if_t, is_convertible, is_assignable
 
-#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif                          // defined(_MSC_VER) && _MSC_VER < 1910
+#if !defined(GSL_NO_IOSTREAMS)
+#include <iosfwd> // for ostream
+#endif            // !defined(GSL_NO_IOSTREAMS)
 
 namespace gsl
 {
 
+namespace details
+{
+    template <typename T, typename = void>
+    struct is_comparable_to_nullptr : std::false_type
+    {
+    };
+
+    template <typename T>
+    struct is_comparable_to_nullptr<
+        T,
+        std::enable_if_t<std::is_convertible<decltype(std::declval<T>() != nullptr), bool>::value>>
+        : std::true_type
+    {
+    };
+} // namespace details
+
 //
 // GSL.owner: ownership pointers
 //
-using std::unique_ptr;
 using std::shared_ptr;
+using std::unique_ptr;
 
 //
 // owner
 //
-// owner<T> is designed as a bridge for code that must deal directly with owning pointers for some reason
+// owner<T> is designed as a bridge for code that must deal directly with owning pointers for some
+// reason
 //
 // T must be a pointer type
 // - disallow construction from any type other than pointer type
@@ -69,7 +84,7 @@ template <class T>
 class not_null
 {
 public:
-    static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr.");
+    static_assert(details::is_comparable_to_nullptr<T>::value, "T cannot be compared to nullptr.");
 
     template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
     constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
@@ -78,27 +93,25 @@ public:
     }
 
     template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr not_null(T u) : ptr_(u)
+    constexpr not_null(T u) : ptr_(std::move(u))
     {
         Expects(ptr_ != nullptr);
     }
 
     template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
     constexpr not_null(const not_null<U>& other) : not_null(other.get())
-    {
-    }
+    {}
 
     not_null(const not_null& other) = default;
     not_null& operator=(const not_null& other) = default;
-
-    constexpr T get() const
+    constexpr std::conditional_t<std::is_copy_constructible<T>::value, T, const T&> get() const
     {
         Ensures(ptr_ != nullptr);
         return ptr_;
     }
 
     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
@@ -119,49 +132,64 @@ private:
 };
 
 template <class T>
-auto make_not_null(T&& t) {
+auto make_not_null(T&& t) noexcept
+{
     return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
 }
 
+#if !defined(GSL_NO_IOSTREAMS)
 template <class T>
 std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
 {
     os << val.get();
     return os;
 }
+#endif // !defined(GSL_NO_IOSTREAMS)
 
 template <class T, class U>
-auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() == rhs.get())
+auto operator==(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get()))
+    -> decltype(lhs.get() == rhs.get())
 {
     return lhs.get() == rhs.get();
 }
 
 template <class T, class U>
-auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() != rhs.get())
+auto operator!=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get()))
+    -> decltype(lhs.get() != rhs.get())
 {
     return lhs.get() != rhs.get();
 }
 
 template <class T, class U>
-auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() < rhs.get())
+auto operator<(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(lhs.get() < rhs.get()))
+    -> decltype(lhs.get() < rhs.get())
 {
     return lhs.get() < rhs.get();
 }
 
 template <class T, class U>
-auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() <= rhs.get())
+auto operator<=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() <= rhs.get()))
+    -> decltype(lhs.get() <= rhs.get())
 {
     return lhs.get() <= rhs.get();
 }
 
 template <class T, class U>
-auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() > rhs.get())
+auto operator>(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(lhs.get() > rhs.get()))
+    -> decltype(lhs.get() > rhs.get())
 {
     return lhs.get() > rhs.get();
 }
 
 template <class T, class U>
-auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() >= rhs.get())
+auto operator>=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() >= rhs.get()))
+    -> decltype(lhs.get() >= rhs.get())
 {
     return lhs.get() >= rhs.get();
 }
@@ -183,7 +211,7 @@ namespace std
 template <class T>
 struct hash<gsl::not_null<T>>
 {
-    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); }
+    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value.get()); }
 };
 
 } // namespace std
@@ -209,28 +237,23 @@ namespace gsl
 //   - remove unnecessary asserts
 //
 template <class T>
-class strict_not_null: public not_null<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))
+    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)
+    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)
+    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)
+    constexpr strict_not_null(const strict_not_null<U>& other) : not_null<T>(other)
     {}
 
     strict_not_null(strict_not_null&& other) = default;
@@ -267,15 +290,18 @@ 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) {
+auto make_strict_not_null(T&& t) noexcept
+{
     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) )
+#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>;
+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) )
 
@@ -286,16 +312,12 @@ 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); }
+    std::size_t operator()(const gsl::strict_not_null<T>& value) const
+    {
+        return hash<T>{}(value.get());
+    }
 };
 
 } // namespace std
 
-#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
-
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
-
 #endif // GSL_POINTERS_H

include/gsl/span

@@ -17,13 +17,15 @@
 #ifndef GSL_SPAN_H
 #define GSL_SPAN_H
 
-#include <gsl/gsl_assert> // for Expects
-#include <gsl/gsl_byte>   // for byte
+#include <gsl/assert> // for Expects
+#include <gsl/byte>   // for byte
+#include <gsl/util>   // for narrow_cast
 
-#include <array>       // for array
-#include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
-#include <iterator>    // for reverse_iterator, distance, random_access_...
-#include <type_traits> // for enable_if_t, declval, is_convertible, inte...
+#include <array>        // for array
+#include <cstddef>      // for ptrdiff_t, size_t, nullptr_t
+#include <gsl/span_ext> // for span specialization of gsl::at and other span-related extensions
+#include <iterator>     // for reverse_iterator, distance, random_access_...
+#include <type_traits>  // for enable_if_t, declval, is_convertible, inte...
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(push)
@@ -38,12 +40,6 @@
 #pragma warning(disable : 26495) // uninitalized member when constructor calls constructor
 #pragma warning(disable : 26446) // parser bug does not allow attributes on some templates
 
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
-
-#endif // _MSC_VER < 1910
 #endif // _MSC_VER
 
 // See if we have enough C++17 power to use a static constexpr data member
@@ -65,12 +61,6 @@
 namespace gsl
 {
 
-// [views.constants], constants
-constexpr const std::size_t dynamic_extent = static_cast<std::size_t>(-1);
-
-template <class ElementType, std::size_t Extent = dynamic_extent>
-class span;
-
 // implementation details
 namespace details
 {
@@ -106,7 +96,7 @@ namespace details
 
     template <std::size_t From, std::size_t To>
     struct is_allowed_extent_conversion
-        : std::integral_constant<bool, From == To || To == gsl::dynamic_extent>
+        : std::integral_constant<bool, From == To || To == dynamic_extent>
     {
     };
 
@@ -157,6 +147,9 @@ namespace details
         {
             Expects(begin_ && current_ && end_);
             Expects(current_ < end_);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
             ++current_;
             return *this;
         }
@@ -188,6 +181,9 @@ namespace details
             if (n != 0) Expects(begin_ && current_ && end_);
             if (n > 0) Expects(end_ - current_ >= n);
             if (n < 0) Expects(current_ - begin_ >= -n);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
             current_ += n;
             return *this;
         }
@@ -343,17 +339,18 @@ namespace details
 
         constexpr extent_type() noexcept = default;
 
-        template <size_type Other>
-        constexpr extent_type(extent_type<Other> ext)
-        {
-            static_assert(Other == Ext,
-                          "Mismatch between fixed-size extent and size of initializing data.");
-            Expects(ext.size() == Ext);
-        }
+        constexpr explicit extent_type(extent_type<dynamic_extent>);
 
-        constexpr extent_type(size_type size) { Expects(size == Ext); }
+        constexpr explicit extent_type(size_type size) { Expects(size == Ext); }
 
         constexpr size_type size() const noexcept { return Ext; }
+
+    private:
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+        static constexpr const size_type size_ = Ext; // static size equal to Ext
+#else
+        static constexpr size_type size_ = Ext; // static size equal to Ext
+#endif
     };
 
     template <>
@@ -363,10 +360,10 @@ namespace details
         using size_type = std::size_t;
 
         template <size_type Other>
-        explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
+        constexpr explicit extent_type(extent_type<Other> ext) : size_(ext.size())
         {}
 
-        explicit constexpr extent_type(size_type size) : size_(size)
+        constexpr explicit extent_type(size_type size) : size_(size)
         {
             Expects(size != dynamic_extent);
         }
@@ -377,6 +374,12 @@ namespace details
         size_type size_;
     };
 
+    template <std::size_t Ext>
+    constexpr extent_type<Ext>::extent_type(extent_type<dynamic_extent> ext)
+    {
+        Expects(ext.size() == Ext);
+    }
+
     template <class ElementType, std::size_t Extent, std::size_t Offset, std::size_t Count>
     struct calculate_subspan_type
     {
@@ -420,22 +423,32 @@ public:
     constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
     {}
 
-    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
+    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
     {
-        if (Extent != dynamic_extent) Expects(count == Extent);
+        Expects(count == Extent);
     }
 
-    constexpr span(pointer firstElem, pointer lastElem) noexcept
-        : storage_(firstElem, static_cast<std::size_t>(lastElem - firstElem))
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
+    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    {}
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
+    constexpr explicit span(pointer firstElem, pointer lastElem) noexcept
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
     {
-        if (Extent != dynamic_extent)
-        { Expects(lastElem - firstElem == static_cast<difference_type>(Extent)); }
+        Expects(lastElem - firstElem == static_cast<difference_type>(Extent));
     }
 
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
+    constexpr span(pointer firstElem, pointer lastElem) noexcept
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
+    {}
+
     template <std::size_t N,
               std::enable_if_t<details::is_allowed_extent_conversion<N, Extent>::value, int> = 0>
     constexpr span(element_type (&arr)[N]) noexcept
-        : storage_(KnownNotNull{arr + 0}, details::extent_type<N>())
+        : storage_(KnownNotNull{arr}, details::extent_type<N>())
     {}
 
     template <
@@ -456,40 +469,78 @@ public:
         : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
     {}
 
-    // NB: the SFINAE here uses .data() as an incomplete/imperfect proxy for the requirement
-    // on Container to be a contiguous sequence container.
-    template <class Container,
-              class = std::enable_if_t<
-                  !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
-                  std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
-                  std::is_convertible<
-                      std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
-                      element_type (*)[]>::value>>
+    // NB: the SFINAE on these constructors uses .data() as an incomplete/imperfect proxy for the
+    // requirement on Container to be a contiguous sequence container.
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent != dynamic_extent && !details::is_span<Container>::value &&
+                      !details::is_std_array<Container>::value &&
+                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                      std::is_convertible<
+                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                          element_type (*)[]>::value,
+                  int> = 0>
+    constexpr explicit span(Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent == dynamic_extent && !details::is_span<Container>::value &&
+                      !details::is_std_array<Container>::value &&
+                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                      std::is_convertible<
+                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                          element_type (*)[]>::value,
+                  int> = 0>
     constexpr span(Container& cont) noexcept : span(cont.data(), cont.size())
     {}
 
-    template <class Container,
-              class = std::enable_if_t<
-                  std::is_const<element_type>::value && !details::is_span<Container>::value &&
-                  !details::is_std_array<Container>::value &&
-                  std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
-                  std::is_convertible<std::remove_pointer_t<
-                                          decltype(std::declval<const Container&>().data())> (*)[],
-                                      element_type (*)[]>::value>>
+    template <
+        std::size_t MyExtent = Extent, class Container,
+        std::enable_if_t<
+            MyExtent != dynamic_extent && std::is_const<element_type>::value &&
+                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                std::is_convertible<
+                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
+                    element_type (*)[]>::value,
+            int> = 0>
+    constexpr explicit span(const Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <
+        std::size_t MyExtent = Extent, class Container,
+        std::enable_if_t<
+            MyExtent == dynamic_extent && std::is_const<element_type>::value &&
+                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                std::is_convertible<
+                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
+                    element_type (*)[]>::value,
+            int> = 0>
     constexpr span(const Container& cont) noexcept : span(cont.data(), cont.size())
     {}
 
     constexpr span(const span& other) noexcept = default;
 
-    template <
-        class OtherElementType, std::size_t OtherExtent,
-        class = std::enable_if_t<
-            details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
-            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
+    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+              std::enable_if_t<(MyExtent == dynamic_extent || MyExtent == OtherExtent) &&
+                                   details::is_allowed_element_type_conversion<OtherElementType,
+                                                                               element_type>::value,
+                               int> = 0>
     constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
         : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
     {}
 
+    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+              std::enable_if_t<MyExtent != dynamic_extent && OtherExtent == dynamic_extent &&
+                                   details::is_allowed_element_type_conversion<OtherElementType,
+                                                                               element_type>::value,
+                               int> = 0>
+    constexpr explicit span(const span<OtherElementType, OtherExtent>& other) noexcept
+        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
+    {}
+
     ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
 
@@ -498,7 +549,7 @@ public:
     constexpr span<element_type, Count> first() const noexcept
     {
         Expects(Count <= size());
-        return {data(), Count};
+        return span<element_type, Count>{data(), Count};
     }
 
     template <std::size_t Count>
@@ -508,7 +559,7 @@ public:
         constexpr span<element_type, Count> last() const noexcept
     {
         Expects(Count <= size());
-        return {data() + (size() - Count), Count};
+        return span<element_type, Count>{data() + (size() - Count), Count};
     }
 
     template <std::size_t Offset, std::size_t Count = dynamic_extent>
@@ -519,8 +570,9 @@ public:
         typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
     {
         Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)));
-
-        return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
+        using type =
+            typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type;
+        return type{data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
     }
 
     constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept
@@ -535,9 +587,8 @@ public:
         return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{});
     }
 
-    constexpr span<element_type, dynamic_extent> subspan(size_type offset,
-                                                         size_type count = dynamic_extent) const
-        noexcept
+    constexpr span<element_type, dynamic_extent>
+    subspan(size_type offset, size_type count = dynamic_extent) const noexcept
     {
         return make_subspan(offset, count, subspan_selector<Extent>{});
     }
@@ -660,9 +711,8 @@ private:
     };
 
     template <std::size_t CallerExtent>
-    constexpr span<element_type, dynamic_extent> make_subspan(size_type offset, size_type count,
-                                                              subspan_selector<CallerExtent>) const
-        noexcept
+    constexpr span<element_type, dynamic_extent>
+    make_subspan(size_type offset, size_type count, subspan_selector<CallerExtent>) const noexcept
     {
         const span<element_type, dynamic_extent> tmp(*this);
         return tmp.subspan(offset, count);
@@ -687,13 +737,21 @@ private:
 
 // Deduction Guides
 template <class Type, std::size_t Extent>
-span(Type (&)[Extent])->span<Type, Extent>;
+span(Type (&)[Extent]) -> span<Type, Extent>;
 
 template <class Type, std::size_t Size>
-span(std::array<Type, Size>&)->span<Type, Size>;
+span(std::array<Type, Size>&) -> span<Type, Size>;
 
 template <class Type, std::size_t Size>
-span(const std::array<Type, Size>&)->span<const Type, Size>;
+span(const std::array<Type, Size>&) -> span<const Type, Size>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
+span(Container&) -> span<Element>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
+span(const Container&) -> span<Element>;
 
 #endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
 
@@ -728,10 +786,12 @@ template <class ElementType, std::size_t Extent>
 span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_bytes(span<ElementType, Extent> s) noexcept
 {
+    using type = span<const byte, details::calculate_byte_size<ElementType, Extent>::value>;
+
     // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
     // clang-format on
-    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
+    return type{reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
 }
 
 template <class ElementType, std::size_t Extent,
@@ -739,20 +799,17 @@ template <class ElementType, std::size_t Extent,
 span<byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_writable_bytes(span<ElementType, Extent> s) noexcept
 {
+    using type = span<byte, details::calculate_byte_size<ElementType, Extent>::value>;
+
     // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
     // clang-format on
-    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
+    return type{reinterpret_cast<byte*>(s.data()), s.size_bytes()};
 }
 
 } // namespace gsl
 
 #if defined(_MSC_VER) && !defined(__clang__)
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
 
 #pragma warning(pop)
 #endif // _MSC_VER

include/gsl/span_ext

@@ -27,17 +27,29 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <gsl/assert> // GSL_KERNEL_MODE
+#include <gsl/util>   // for narrow_cast, narrow
 
-#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 <cstddef> // for ptrdiff_t, size_t
 #include <utility>
 
+#ifndef GSL_KERNEL_MODE
+#include <algorithm> // for lexicographical_compare
+#endif               // GSL_KERNEL_MODE
+
 namespace gsl
 {
 
+// [span.views.constants], constants
+constexpr const std::size_t dynamic_extent = narrow_cast<std::size_t>(-1);
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+class span;
+
+// std::equal and std::lexicographical_compare are not /kernel compatible
+// so all comparison operators must be removed for kernel mode.
+#ifndef GSL_KERNEL_MODE
+
 // [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)
@@ -75,6 +87,8 @@ constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent>
     return !(l < r);
 }
 
+#endif // GSL_KERNEL_MODE
+
 //
 // make_span() - Utility functions for creating spans
 //

include/gsl/string_span

@@ -17,16 +17,16 @@
 #ifndef GSL_STRING_SPAN_H
 #define GSL_STRING_SPAN_H
 
-#include <gsl/gsl_assert> // for Ensures, Expects
-#include <gsl/gsl_util>   // for narrow_cast
-#include <gsl/span_ext>       // for operator!=, operator==, dynamic_extent
+#include <gsl/assert>   // for Ensures, Expects
+#include <gsl/span_ext> // for operator!=, operator==, dynamic_extent
+#include <gsl/util>     // for narrow_cast
 
 #include <algorithm> // for equal, lexicographical_compare
 #include <array>     // for array
 #include <cstddef>   // for size_t, nullptr_t
 #include <cstdint>   // for PTRDIFF_MAX
 #include <cstring>
-#include <string>    // for basic_string, allocator, char_traits
+#include <string>      // for basic_string, allocator, char_traits
 #include <type_traits> // for declval, is_convertible, enable_if_t, add_...
 
 #if defined(_MSC_VER) && !defined(__clang__)
@@ -35,13 +35,13 @@
 // Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
 #pragma warning(disable : 26446) // TODO: bug in parser - attributes and templates
 #pragma warning(disable : 26481) // TODO: suppress does not work inside templates sometimes
+#pragma warning(disable : 4996)  // use of functions & classes marked [[deprecated]]
+#endif                           // _MSC_VER
 
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif // _MSC_VER < 1910
-#endif // _MSC_VER
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
 
 namespace gsl
 {
@@ -59,34 +59,28 @@ namespace gsl
 template <typename CharT, std::size_t Extent = dynamic_extent>
 using basic_zstring = CharT*;
 
-template <std::size_t Extent = dynamic_extent>
-using czstring = basic_zstring<const char, Extent>;
+using czstring = basic_zstring<const char, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using cwzstring = basic_zstring<const wchar_t, Extent>;
+using cwzstring = basic_zstring<const wchar_t, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using cu16zstring = basic_zstring<const char16_t, Extent>;
+using cu16zstring = basic_zstring<const char16_t, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using cu32zstring = basic_zstring<const char32_t, Extent>;
+using cu32zstring = basic_zstring<const char32_t, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using zstring = basic_zstring<char, Extent>;
+using zstring = basic_zstring<char, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using wzstring = basic_zstring<wchar_t, Extent>;
+using wzstring = basic_zstring<wchar_t, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using u16zstring = basic_zstring<char16_t, Extent>;
+using u16zstring = basic_zstring<char16_t, dynamic_extent>;
 
-template <std::size_t Extent = dynamic_extent>
-using u32zstring = basic_zstring<char32_t, Extent>;
+using u32zstring = basic_zstring<char32_t, dynamic_extent>;
 
 namespace details
 {
     template <class CharT>
-    std::size_t string_length(const CharT* str, std::size_t n)
+    [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+                 "isocpp/CppCoreGuidelines PR#1680")]] constexpr std::size_t
+    string_length(const CharT* str, std::size_t n)
     {
         if (str == nullptr || n == dynamic_extent) return 0;
 
@@ -108,73 +102,86 @@ namespace details
 // Will fail-fast if sentinel cannot be found before max elements are examined.
 //
 template <typename T, const T Sentinel>
-span<T, dynamic_extent> ensure_sentinel(T* seq,
-                                        std::size_t max = static_cast<std::size_t>(-1))
+[[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+             "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<T, dynamic_extent>
+ensure_sentinel(T* seq, std::size_t max = static_cast<std::size_t>(-1))
 {
     Ensures(seq != nullptr);
 
-    GSL_SUPPRESS(
-        f.23) // NO-FORMAT: attribute // TODO: false positive // TODO: suppress does not work
+    // clang-format off
+    GSL_SUPPRESS(f.23) // TODO: false positive // TODO: suppress does not work
+    // clang-format on
     auto cur = seq;
     Ensures(cur != nullptr); // workaround for removing the warning
 
-    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute // TODO: suppress does not work
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // TODO: suppress does not work
+    // clang-format on
     while (static_cast<std::size_t>(cur - seq) < max && *cur != Sentinel) ++cur;
     Ensures(*cur == Sentinel);
     return {seq, static_cast<std::size_t>(cur - seq)};
 }
 
 //
-// ensure_z - creates a span for a zero terminated strings.
-// Will fail fast if a null-terminator cannot be found before
-// the limit of size_type.
+// ensure_z - creates a span for a zero terminated strings. The span will not contain the zero
+// termination. Will fail fast if a null-terminator cannot be found before the limit of size_type.
 //
 template <typename CharT>
-span<CharT, dynamic_extent> ensure_z(CharT* const& sz,
-                                     std::size_t max = static_cast<std::size_t>(-1))
+[[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+             "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<CharT, dynamic_extent>
+ensure_z(CharT* const& sz, std::size_t max = static_cast<std::size_t>(-1))
 {
     return ensure_sentinel<CharT, CharT(0)>(sz, max);
 }
 
 template <typename CharT, std::size_t N>
-span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
+constexpr span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
 {
     return ensure_z(&sz[0], N);
 }
 
 template <class Cont>
-span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
+[[deprecated(
+    "string_span was removed from the C++ Core Guidelines. For more information, see "
+    "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<typename std::
+                                                             remove_pointer<
+                                                                 typename Cont::pointer>::type,
+                                                         dynamic_extent>
 ensure_z(Cont& cont)
 {
     return ensure_z(cont.data(), cont.size());
 }
 
 template <typename CharT, std::size_t>
-class basic_string_span;
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_string_span;
 
 namespace details
 {
     template <typename T>
-    struct is_basic_string_span_oracle : std::false_type
-    {
-    };
+    struct [[deprecated(
+        "string_span was removed from the C++ Core Guidelines. For more information, "
+        "see isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span_oracle : std::false_type{};
 
     template <typename CharT, std::size_t Extent>
-    struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type
-    {
-    };
+    struct [[deprecated(
+        "string_span was removed from the C++ Core Guidelines. For more information, see "
+        "isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span_oracle<basic_string_span<CharT,
+                                                                                            Extent>>
+        : std::true_type{};
 
     template <typename T>
-    struct is_basic_string_span : is_basic_string_span_oracle<std::remove_cv_t<T>>
-    {
-    };
+    struct [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                        "information, see isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span
+        : is_basic_string_span_oracle<std::remove_cv_t<T>>{};
 } // namespace details
 
 //
 // string_span and relatives
 //
 template <typename CharT, std::size_t Extent = dynamic_extent>
-class basic_string_span
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_string_span
 {
 public:
     using element_type = CharT;
@@ -203,11 +210,11 @@ public:
     // From static arrays - if 0-terminated, remove 0 from the view
     // All other containers allow 0s within the length, so we do not remove them
     template <std::size_t N>
-    constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr))
+    constexpr basic_string_span(element_type(&arr)[N]) : span_(remove_z(arr))
     {}
 
     template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
+    constexpr basic_string_span(std::array<ArrayElementType, N> & arr) noexcept : span_(arr)
     {}
 
     template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
@@ -216,8 +223,8 @@ public:
 
     // Container signature should work for basic_string after C++17 version exists
     template <class Traits, class Allocator>
-    // GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute // TODO: parser bug
-    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str)
+    // GSL_SUPPRESS(bounds.4) // TODO: parser bug
+    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator> & str)
         : span_(&str[0], str.length())
     {}
 
@@ -233,7 +240,7 @@ public:
                   std::is_convertible<typename Container::pointer, pointer>::value &&
                   std::is_convertible<typename Container::pointer,
                                       decltype(std::declval<Container>().data())>::value>>
-    constexpr basic_string_span(Container& cont) : span_(cont)
+    constexpr basic_string_span(Container & cont) : span_(cont)
     {}
 
     template <class Container,
@@ -282,8 +289,8 @@ public:
         return {span_.template subspan<Offset, Count>()};
     }
 
-    constexpr basic_string_span<element_type, dynamic_extent>
-    subspan(size_type offset, size_type count = dynamic_extent) const
+    constexpr basic_string_span<element_type, dynamic_extent> subspan(
+        size_type offset, size_type count = dynamic_extent) const
     {
         return {span_.subspan(offset, count)};
     }
@@ -306,13 +313,13 @@ public:
     constexpr reverse_iterator rend() const noexcept { return span_.rend(); }
 
 private:
-    static impl_type remove_z(pointer const& sz, std::size_t max)
+    static constexpr impl_type remove_z(pointer const& sz, std::size_t max)
     {
-        return {sz, details::string_length(sz, max)};
+        return impl_type(sz, details::string_length(sz, max));
     }
 
     template <std::size_t N>
-    static impl_type remove_z(element_type (&sz)[N])
+    static constexpr impl_type remove_z(element_type(&sz)[N])
     {
         return remove_z(&sz[0], N);
     }
@@ -321,35 +328,51 @@ private:
 };
 
 template <std::size_t Extent = dynamic_extent>
-using string_span = basic_string_span<char, Extent>;
+using string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using cstring_span = basic_string_span<const char, Extent>;
+using cstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using wstring_span = basic_string_span<wchar_t, Extent>;
+using wstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<wchar_t, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using cwstring_span = basic_string_span<const wchar_t, Extent>;
+using cwstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const wchar_t, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using u16string_span = basic_string_span<char16_t, Extent>;
+using u16string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char16_t, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using cu16string_span = basic_string_span<const char16_t, Extent>;
+using cu16string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char16_t, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using u32string_span = basic_string_span<char32_t, Extent>;
+using u32string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char32_t, Extent>;
 
 template <std::size_t Extent = dynamic_extent>
-using cu32string_span = basic_string_span<const char32_t, Extent>;
+using cu32string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char32_t, Extent>;
 
 //
 // to_string() allow (explicit) conversions from string_span to string
 //
 
 template <typename CharT, std::size_t Extent>
-std::basic_string<typename std::remove_const<CharT>::type>
+constexpr std::basic_string<typename std::remove_const<CharT>::type>
 to_string(basic_string_span<CharT, Extent> view)
 {
     return {view.data(), narrow_cast<std::size_t>(view.length())};
@@ -357,32 +380,38 @@ to_string(basic_string_span<CharT, Extent> view)
 
 template <typename CharT, typename Traits = typename std::char_traits<CharT>,
           typename Allocator = std::allocator<CharT>, typename gCharT, std::size_t Extent>
-std::basic_string<CharT, Traits, Allocator> to_basic_string(basic_string_span<gCharT, Extent> view)
+constexpr std::basic_string<CharT, Traits, Allocator>
+to_basic_string(basic_string_span<gCharT, Extent> view)
 {
     return {view.data(), narrow_cast<std::size_t>(view.length())};
 }
 
 template <class ElementType, std::size_t Extent>
-basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+constexpr basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_bytes(basic_string_span<ElementType, Extent> s) noexcept
 {
-    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format off
+    GSL_SUPPRESS(type.1)
+    // clang-format on
     return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
 }
 
 template <class ElementType, std::size_t Extent,
           class = std::enable_if_t<!std::is_const<ElementType>::value>>
-basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+constexpr basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_writable_bytes(basic_string_span<ElementType, Extent> s) noexcept
 {
-    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format off
+    GSL_SUPPRESS(type.1)
+    // clang-format on
     return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
 }
 
 // zero-terminated string span, used to convert
 // zero-terminated spans to legacy strings
 template <typename CharT, std::size_t Extent = dynamic_extent>
-class basic_zstring_span
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_zstring_span
 {
 public:
     using value_type = CharT;
@@ -400,14 +429,15 @@ public:
     constexpr basic_zstring_span(impl_type s) : span_(s)
     {
         // expects a zero-terminated span
-        Expects(s[s.size() - 1] == '\0');
+        Expects(s.size() > 0);
+        Expects(s[s.size() - 1] == value_type{});
     }
 
     // copy
     constexpr basic_zstring_span(const basic_zstring_span& other) = default;
 
     // move
-    constexpr basic_zstring_span(basic_zstring_span&& other) = default;
+    constexpr basic_zstring_span(basic_zstring_span && other) = default;
 
     // assign
     constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default;
@@ -415,12 +445,11 @@ public:
     // move assign
     constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;
 
-    constexpr bool empty() const noexcept { return span_.size() == 0; }
+    constexpr bool empty() const noexcept { return false; }
 
     constexpr string_span_type as_string_span() const noexcept
     {
-        const auto sz = span_.size();
-        return {span_.data(), sz > 1 ? sz - 1 : 0};
+        return {span_.data(), span_.size() - 1};
     }
     constexpr string_span_type ensure_z() const { return gsl::ensure_z(span_); }
 
@@ -431,28 +460,44 @@ private:
 };
 
 template <std::size_t Max = dynamic_extent>
-using zstring_span = basic_zstring_span<char, Max>;
+using zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using wzstring_span = basic_zstring_span<wchar_t, Max>;
+using wzstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<wchar_t, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using u16zstring_span = basic_zstring_span<char16_t, Max>;
+using u16zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char16_t, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using u32zstring_span = basic_zstring_span<char32_t, Max>;
+using u32zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char32_t, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using czstring_span = basic_zstring_span<const char, Max>;
+using czstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
+using cwzstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const wchar_t, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using cu16zstring_span = basic_zstring_span<const char16_t, Max>;
+using cu16zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For "
+                                    "more information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char16_t, Max>;
 
 template <std::size_t Max = dynamic_extent>
-using cu32zstring_span = basic_zstring_span<const char32_t, Max>;
+using cu32zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For "
+                                    "more information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char32_t, Max>;
 
 // operator ==
 template <class CharT, std::size_t Extent, class T,
@@ -476,7 +521,7 @@ bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other
 }
 
 // operator !=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -485,7 +530,7 @@ bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -495,7 +540,7 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 }
 
 // operator<
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -505,7 +550,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -521,7 +566,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -535,7 +580,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -550,7 +595,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif
 
 // operator <=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -559,7 +604,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -574,7 +619,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -587,7 +632,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -601,7 +646,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif
 
 // operator>
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -610,7 +655,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -625,7 +670,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -638,7 +683,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -652,7 +697,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif
 
 // operator >=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -661,7 +706,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -676,7 +721,7 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -689,7 +734,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -706,11 +751,9 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(pop)
 
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
 #endif // _MSC_VER
 
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
 #endif // GSL_STRING_SPAN_H

include/gsl/util

@@ -0,0 +1,160 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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_UTIL_H
+#define GSL_UTIL_H
+
+#include <gsl/assert> // for Expects
+
+#include <array>
+#include <cstddef>          // for ptrdiff_t, size_t
+#include <initializer_list> // for initializer_list
+#include <type_traits>      // for is_signed, integral_constant
+#include <utility>          // for exchange, forward
+
+#if defined(__has_include) && __has_include(<version>)
+#include <version>
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+#include <span>
+#endif // __cpp_lib_span >= 202002L
+#endif //__has_include(<version>)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+
+#endif // _MSC_VER
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+#define GSL_NODISCARD [[nodiscard]]
+#else
+#define GSL_NODISCARD
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L)
+
+namespace gsl
+{
+//
+// GSL.util: utilities
+//
+
+// index type for all container indexes/subscripts/sizes
+using index = std::ptrdiff_t;
+
+// final_action allows you to ensure something gets run at the end of a scope
+template <class F>
+class final_action
+{
+public:
+    static_assert(!std::is_reference<F>::value && !std::is_const<F>::value &&
+                      !std::is_volatile<F>::value,
+                  "Final_action should store its callable by value");
+
+    explicit final_action(F f) noexcept : f_(std::move(f)) {}
+
+    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;
+    final_action& operator=(final_action&&) = delete;
+
+    // clang-format off
+    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // terminate if throws
+    // clang-format on
+    ~final_action() noexcept
+    {
+        if (invoke_) f_();
+    }
+
+private:
+    F f_;
+    bool invoke_{true};
+};
+
+// finally() - convenience function to generate a final_action
+template <class F>
+GSL_NODISCARD final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>
+finally(F&& f) noexcept
+{
+    return final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>(
+        std::forward<F>(f));
+}
+
+// narrow_cast(): a searchable way to do narrowing casts of values
+template <class T, class U>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T narrow_cast(U&& u) noexcept
+{
+    return static_cast<T>(std::forward<U>(u));
+}
+
+//
+// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
+//
+template <class T, std::size_t N>
+// clang-format off
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T& at(T (&arr)[N], const index i)
+{
+    Expects(i >= 0 && i < narrow_cast<index>(N));
+    return arr[narrow_cast<std::size_t>(i)];
+}
+
+template <class Cont>
+// clang-format off
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    using size_type = decltype(cont.size());
+    return cont[narrow_cast<size_type>(i)];
+}
+
+template <class T>
+// clang-format off
+GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T at(const std::initializer_list<T> cont, const index i)
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    return *(cont.begin() + i);
+}
+
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+template <class T, size_t extent = std::dynamic_extent>
+constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(sp.size()));
+    return sp[gsl::narrow_cast<size_t>(i)];
+}
+#endif // __cpp_lib_span >= 202002L
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(pop)
+
+#endif // _MSC_VER
+
+#endif // GSL_UTIL_H

pipelines/jobs.yml

@@ -0,0 +1,43 @@
+parameters:
+  CXXVersions: [ 14, 17, 20 ]
+  buildTypes: [ 'Debug', 'Release' ]
+  image: ''
+
+  compiler: ''
+  compilerVersions: ["default"] # if default value, simply uses whatever version is on the machine.
+                                # the text of this default value doesn't actually matter.
+  setupfile: ''
+  extraCmakeArgs: ''
+
+jobs:
+- ${{ each compilerVersion in parameters.compilerVersions }}:
+  - ${{ each CXXVersion in parameters.CXXVersions }}:
+    - ${{ each buildType in parameters.buildTypes }}:
+      - job:
+        displayName: ${{ format('{0} {1} C++{2} {3}', parameters.compiler, compilerVersion, CXXVersion, buildType) }}
+        pool:
+            vmImage: ${{ parameters.image }}
+        continueOnError: false
+
+        steps:
+          - ${{ if not(eq(parameters.setupfile, '')) }}:
+            - template: ${{ parameters.setupfile }}
+              parameters:
+                version: ${{ compilerVersion }}
+
+          - task: CMake@1
+            name: Configure
+            inputs:
+              workingDirectory: build
+              cmakeArgs: '-DGSL_CXX_STANDARD=${{ CXXVersion }} -DCMAKE_BUILD_TYPE=${{ buildType }} -DCI_TESTING:BOOL=ON -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -Werror=dev ${{ parameters.extraCmakeArgs }} .. '
+
+          - task: CMake@1
+            name: Build
+            inputs:
+              workingDirectory: build
+              cmakeArgs: '--build . '
+
+          - script: ctest . --output-on-failure --no-compress-output
+            name: CTest
+            workingDirectory: build
+            failOnStderr: true

pipelines/setup_apple.yml

@@ -0,0 +1,9 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      if [ "${{ parameters.version }}" != "default" ]; then sudo xcode-select -switch /Applications/Xcode_${{ parameters.version }}.app; fi
+
+    displayName: "Setup Xcode Version"
+    failOnStderr: true

pipelines/setup_clang.yml

@@ -0,0 +1,13 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      echo "##vso[task.setvariable variable=CXX;]${CXX}"
+      echo "##vso[task.setvariable variable=CC;]${CC}"
+
+    displayName: "Setup Clang Version"
+    failOnStderr: true
+    env:
+      CC: clang-${{ parameters.version }}
+      CXX: clang++-${{ parameters.version }}

pipelines/setup_gcc.yml

@@ -0,0 +1,14 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      echo "##vso[task.setvariable variable=CXX;]${CXX}"
+      echo "##vso[task.setvariable variable=CC;]${CC}"
+      if [ "${{ parameters.version }}" = "11" ]; then sudo apt-get install $CXX; fi
+
+    displayName: "Setup GCC Version"
+    failOnStderr: true
+    env:
+      CC: gcc-${{ parameters.version }}
+      CXX: g++-${{ parameters.version }}

tests/CMakeLists.txt

@@ -1,38 +1,64 @@
 cmake_minimum_required(VERSION 3.0.2)
 
 project(GSLTests CXX)
+enable_testing()  # again, for support standalone testing
+
+include(FindPkgConfig)
+include(ExternalProject)
 
 # will make visual studio generated project group files
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-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(result)
-    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+if(CI_TESTING AND GSL_CXX_STANDARD EQUAL 20)
+    add_compile_definitions(FORCE_STD_SPAN_TESTS=1)
 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}")
+if(IOS)
+    add_compile_definitions(GTEST_HAS_DEATH_TEST=1 IOS_PROCESS_DELAY_WORKAROUND=1)
 endif()
 
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+pkg_search_module(GTestMain gtest_main)
+if (NOT GTestMain_FOUND)
+    # No pre-installed GTest is available, try to download it using Git.
+    find_package(Git REQUIRED QUIET)
 
-add_subdirectory(
-    ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
-    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
-    EXCLUDE_FROM_ALL
-)
+    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(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
 
-if (MSVC AND (GSL_CXX_STANDARD EQUAL 17))
+    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)
+    set(GTestMain_LIBRARIES gtest_main)
+
+    add_subdirectory(
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
+        EXCLUDE_FROM_ALL
+    )
+endif()
+
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    # CMake has been started independently in this directory with tests. Do
+    # import the globally installed Guidelines Support Library and test it
+    # instead of the current version from the include/ folder.
+    find_package(Microsoft.GSL REQUIRED)
+endif()
+
+if (MSVC AND (GSL_CXX_STANDARD GREATER_EQUAL 17))
     set(GSL_CPLUSPLUS_OPT -Zc:__cplusplus -permissive-)
 endif()
 
@@ -113,6 +139,11 @@ else()
           $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.99>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
             $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
           >
+          $<$<AND:$<EQUAL:${GSL_CXX_STANDARD},20>,$<OR:$<CXX_COMPILER_VERSION:11.0.0>,$<CXX_COMPILER_VERSION:10.0.0>>>:
+              -Wno-zero-as-null-pointer-constant  # failing Clang Ubuntu 20.04 tests, seems to be a bug with clang 10.0.0
+                                                  # and clang 11.0.0. (operator< is being re-written by the compiler
+                                                  # as operator<=> and raising the warning)
+          >
         >
         $<$<CXX_COMPILER_ID:AppleClang>:
           $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,9.1>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,10>>:
@@ -142,39 +173,27 @@ target_include_directories(gsl_tests_config SYSTEM INTERFACE
     googletest/googletest/include
 )
 
-set_property(TARGET  PROPERTY FOLDER "GSL_tests")
-
-function(add_gsl_test name)
-    add_executable(${name} ${name}.cpp)
-    target_link_libraries(${name}
-        GSL
-        gsl_tests_config
-        gtest_main
-    )
-    add_test(
-        ${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)
-add_gsl_test(at_tests)
-add_gsl_test(bounds_tests)
-add_gsl_test(notnull_tests)
-add_gsl_test(assertion_tests)
-add_gsl_test(utils_tests)
-add_gsl_test(owner_tests)
-add_gsl_test(byte_tests)
-add_gsl_test(algorithm_tests)
-add_gsl_test(strict_notnull_tests)
+add_executable(gsl_tests
+    algorithm_tests.cpp
+    assertion_tests.cpp
+    at_tests.cpp
+    byte_tests.cpp
+    notnull_tests.cpp
+    owner_tests.cpp
+    span_compatibility_tests.cpp
+    span_ext_tests.cpp
+    span_tests.cpp
+    strict_notnull_tests.cpp
+    string_span_tests.cpp
+    utils_tests.cpp
+)
 
+target_link_libraries(gsl_tests
+    Microsoft.GSL::GSL
+    gsl_tests_config
+    ${GTestMain_LIBRARIES}
+)
+add_test(gsl_tests gsl_tests)
 
 # No exception tests
 
@@ -249,19 +268,9 @@ else()
     )
 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}
-      ${name}
-    )
-    # group all tests under GSL_tests_noexcept
-    set_property(TARGET ${name} PROPERTY FOLDER "GSL_tests_noexcept")
-endfunction()
-
-add_gsl_test_noexcept(no_exception_ensure_tests)
+add_executable(gsl_noexcept_tests no_exception_ensure_tests.cpp)
+target_link_libraries(gsl_noexcept_tests
+    Microsoft.GSL::GSL
+    gsl_tests_config_noexcept
+)
+add_test(gsl_noexcept_tests gsl_noexcept_tests)

tests/CMakeLists.txt.in

@@ -4,7 +4,7 @@ project(googletest-download NONE)
 include(ExternalProject)
 ExternalProject_Add(googletest
   GIT_REPOSITORY    https://github.com/google/googletest.git
-  GIT_TAG           703bd9caab50b139428cea1aaff9974ebee5742e
+  GIT_TAG           1b18723e874b256c1e39378c6774a90701d70f7a
   SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
   BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
   CONFIGURE_COMMAND ""

tests/algorithm_tests.cpp

@@ -14,23 +14,19 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <array>         // for array
+#include <cstddef>       // for size_t
+#include <gsl/algorithm> // for copy
+#include <gsl/span>      // for span
 #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
-{
-    static constexpr char deathstring[] = "Expected Death";
-}
+#include "deathTestCommon.h"
 
 namespace gsl
 {
 struct fail_fast;
 } // namespace gsl
 
-using namespace std;
 using namespace gsl;
 
 TEST(algorithm_tests, same_type)
@@ -76,8 +72,8 @@ TEST(algorithm_tests, same_type)
         std::array<int, 5> src{1, 2, 3, 4, 5};
         std::array<int, 10> dst{};
 
-        const span<int> src_span(src);
-        const span<int, 10> dst_span(dst);
+        const gsl::span<int> src_span(src);
+        const gsl::span<int, 10> dst_span(dst);
 
         copy(src_span, dst_span);
         copy(src_span, dst_span.subspan(src_span.size()));
@@ -204,10 +200,11 @@ TEST(algorithm_tests, incompatible_type)
 
 TEST(algorithm_tests, small_destination_span)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. small_destination_span";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     std::array<int, 12> src{1, 2, 3, 4};
     std::array<int, 4> dst{};
@@ -217,9 +214,9 @@ TEST(algorithm_tests, small_destination_span)
     const span<int> dst_span_dyn(dst);
     const span<int, 4> dst_span_static(dst);
 
-    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);
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_dyn), expected);
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_static), expected);
+    EXPECT_DEATH(copy(src_span_static, dst_span_dyn), expected);
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     copy(src_span_static, dst_span_static);

tests/assertion_tests.cpp

@@ -14,14 +14,14 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include "deathTestCommon.h"
+#include <gsl/assert> // for fail_fast (ptr only), Ensures, Expects
 #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)
 {
@@ -39,23 +39,22 @@ int g(int i)
 
 TEST(assertion_tests, expects)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. expects";
         std::abort();
     });
 
     EXPECT_TRUE(f(2) == 2);
-    EXPECT_DEATH(f(10), deathstring);
+    EXPECT_DEATH(f(10), GetExpectedDeathString(terminateHandler));
 }
 
-
 TEST(assertion_tests, ensures)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. ensures";
         std::abort();
     });
 
     EXPECT_TRUE(g(2) == 3);
-    EXPECT_DEATH(g(9), deathstring);
+    EXPECT_DEATH(g(9), GetExpectedDeathString(terminateHandler));
 }

tests/at_tests.cpp

@@ -16,37 +16,39 @@
 
 #include <gtest/gtest.h>
 
-#include <gsl/gsl_util> // for at
+#include <gsl/util> // for at
 
 #include <array>            // for array
 #include <cstddef>          // for size_t
 #include <initializer_list> // for initializer_list
 #include <vector>           // for vector
+#if defined(__cplusplus) && __cplusplus >= 202002L
+#include <span>
+#endif // __cplusplus >= 202002L
 
-namespace
-{
-    static constexpr char deathstring[] = "Expected Death";
-}
+#include "deathTestCommon.h"
 
 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) {
+    for (int i = 0; i < 4; ++i)
+    {
         EXPECT_TRUE(&gsl::at(a, i) == &a[i]);
         EXPECT_TRUE(&gsl::at(c_a, i) == &a[i]);
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. static_array";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
-    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);
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
 }
 
 TEST(at_tests, std_array)
@@ -54,20 +56,22 @@ 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) {
+    for (int i = 0; i < 4; ++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)]);
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. std_array";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
-    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);
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
 }
 
 TEST(at_tests, std_vector)
@@ -75,42 +79,74 @@ 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) {
+    for (int i = 0; i < 4; ++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)]);
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. std_vector";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
-    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);
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
 }
 
 TEST(at_tests, InitializerList)
 {
     const std::initializer_list<int> a = {1, 2, 3, 4};
 
-    for (int i = 0; i < 4; ++i) {
+    for (int i = 0; i < 4; ++i)
+    {
         EXPECT_TRUE(gsl::at(a, i) == i + 1);
         EXPECT_TRUE(gsl::at({1, 2, 3, 4}, i) == i + 1);
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. InitializerList";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
-    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);
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, -1), expected);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, 4), expected);
 }
 
+#if defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+TEST(at_tests, std_span)
+{
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    std::span sp{vec};
+
+    std::vector<int> cvec{1, 2, 3, 4, 5};
+    std::span csp{cvec};
+
+    for (gsl::index i = 0; i < gsl::narrow_cast<gsl::index>(vec.size()); ++i)
+    {
+        EXPECT_TRUE(&gsl::at(sp, i) == &vec[gsl::narrow_cast<size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(csp, i) == &cvec[gsl::narrow_cast<size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_span";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(sp, -1), expected);
+    EXPECT_DEATH(gsl::at(sp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+    EXPECT_DEATH(gsl::at(csp, -1), expected);
+    EXPECT_DEATH(gsl::at(csp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+}
+#endif // defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+
 #if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1910
 static constexpr bool test_constexpr()
 {
@@ -119,7 +155,8 @@ static constexpr bool test_constexpr()
     std::array<int, 4> a2 = {1, 2, 3, 4};
     const std::array<int, 4>& c_a2 = a2;
 
-    for (int i = 0; i < 4; ++i) {
+    for (int i = 0; i < 4; ++i)
+    {
         if (&gsl::at(a1, i) != &a1[i]) return false;
         if (&gsl::at(c_a1, i) != &a1[i]) return false;
         // requires C++17:

tests/bounds_tests.cpp

@@ -1,102 +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 <gtest/gtest.h>
-
-#include <gsl/multi_span> // for static_bounds, static_bounds_dynamic_range_t
-
-#include <cstddef> // for ptrdiff_t, size_t
-
-using namespace std;
-using namespace gsl;
-
-namespace
-{
-void use(std::ptrdiff_t&) {}
-}
-
-TEST(bounds_tests, basic_bounds)
-{
-    for (auto point : static_bounds<dynamic_range, 3, 4>{2}) {
-        for (decltype(point)::size_type j = 0;
-             j < static_cast<decltype(point)::size_type>(decltype(point)::rank); j++)
-        {
-            use(j);
-            use(point[static_cast<std::size_t>(j)]);
-        }
-    }
-}
-
-TEST(bounds_tests, bounds_basic)
-{
-    static_bounds<3, 4, 5> b;
-    const auto a = b.slice();
-    (void) a;
-    static_bounds<4, dynamic_range, 2> x{4};
-    x.slice().slice();
-}
-
-TEST(bounds_tests, arrayview_iterator)
-{
-    static_bounds<4, dynamic_range, 2> bounds{3};
-
-    const auto itr = bounds.begin();
-    (void) itr;
-#ifdef CONFIRM_COMPILATION_ERRORS
-    multi_span<int, 4, dynamic_range, 2> av(nullptr, bounds);
-
-    auto itr2 = av.cbegin();
-
-    for (auto& v : av) {
-        v = 4;
-    }
-    fill(av.begin(), av.end(), 0);
-#endif
-}
-
-TEST(bounds_tests, bounds_convertible)
-{
-    static_bounds<7, 4, 2> b1;
-    static_bounds<7, dynamic_range, 2> b2 = b1;
-    (void) b2;
-#ifdef CONFIRM_COMPILATION_ERRORS
-    static_bounds<7, dynamic_range, 1> b4 = b2;
-#endif
-
-    static_bounds<dynamic_range, dynamic_range, dynamic_range> b3 = b1;
-    static_bounds<7, 4, 2> b4 = b3;
-    (void) b4;
-
-    static_bounds<dynamic_range> b5;
-    static_bounds<34> b6;
-
-    std::set_terminate([] {
-        std::cerr << "Expected Death. bounds_convertible";
-        std::abort();
-    });
-
-    b5 = static_bounds<20>();
-    EXPECT_DEATH(b6 = b5, ".*");
-    b5 = static_bounds<34>();
-    b6 = b5;
-
-    EXPECT_TRUE(b5 == b6);
-    EXPECT_TRUE(b5.size() == b6.size());
-}
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-copy(src_span_static, dst_span_static);
-#endif

tests/byte_tests.cpp

@@ -16,7 +16,7 @@
 
 #include <gtest/gtest.h>
 
-#include <gsl/gsl_byte> // for to_byte, to_integer, byte, operator&, ope...
+#include <gsl/byte> // for to_byte, to_integer, byte, operator&, ope...
 
 using namespace std;
 using namespace gsl;
@@ -37,7 +37,9 @@ TEST(byte_tests, construction)
         EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
     }
 
+    // clang-format off
     GSL_SUPPRESS(es.49)
+    // clang-format on
     {
         const byte b = byte(12);
         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
@@ -55,7 +57,7 @@ TEST(byte_tests, construction)
 
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
     {
-        const byte b { 14 };
+        const byte b{14};
         EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
     }
 #endif
@@ -122,7 +124,7 @@ TEST(byte_tests, aliasing)
     EXPECT_TRUE(res == i);
 }
 
-}
+} // namespace
 
 #ifdef CONFIRM_COMPILATION_ERRORS
 copy(src_span_static, dst_span_static);

tests/deathTestCommon.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <gsl/assert>
+
+constexpr char deathstring[] = "Expected Death";
+constexpr char failed_set_terminate_deathstring[] = ".*";
+
+// This prevents a failed call to set_terminate from failing the test suite.
+constexpr const char* GetExpectedDeathString(std::terminate_handler handle)
+{
+    return handle ? deathstring : failed_set_terminate_deathstring;
+}

tests/no_exception_ensure_tests.cpp

@@ -14,8 +14,11 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <chrono>
 #include <cstdlib>  // for std::exit
 #include <gsl/span> // for span
+#include <iostream>
+#include <thread>
 
 int operator_subscript_no_throw() noexcept
 {
@@ -42,6 +45,10 @@ void setup_termination_handler() noexcept
 
 int main() noexcept
 {
+    std::cout << "Running main() from " __FILE__ "\n";
+#if defined(IOS_PROCESS_DELAY_WORKAROUND)
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+#endif
     setup_termination_handler();
     operator_subscript_no_throw();
     return -1;

tests/notnull_tests.cpp

@@ -25,13 +25,9 @@
 #include <string>    // for basic_string, operator==, string, operator<<
 #include <typeinfo>  // for type_info
 
+#include "deathTestCommon.h"
 using namespace gsl;
 
-namespace
-{
-static constexpr char deathstring[] = "Expected Death";
-} //namespace
-
 struct MyBase
 {
 };
@@ -64,7 +60,9 @@ struct CustomPtr
 template <typename T, typename U>
 std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
+    // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) == reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -72,7 +70,9 @@ std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
+    // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) != reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -80,7 +80,9 @@ std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
+    // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) < reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
 }
@@ -88,7 +90,9 @@ std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
+    // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) > reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
 }
@@ -96,7 +100,9 @@ std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
+    // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) <= reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -104,7 +110,9 @@ std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator>=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
+    // clang-format off
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) >= reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -118,12 +126,19 @@ struct NonCopyableNonMovable
     NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
 };
 
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+namespace
+{
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
 bool helper(not_null<int*> p) { return *p == 12; }
-GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
 bool helper_const(not_null<const int*> p) { return *p == 12; }
 
 int* return_pointer() { return nullptr; }
+} // namespace
 
 TEST(notnull_tests, TestNotNullConstructors)
 {
@@ -142,10 +157,12 @@ TEST(notnull_tests, TestNotNullConstructors)
 #endif
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestNotNullConstructors";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
     {
         // from shared pointer
         int i = 12;
@@ -157,7 +174,7 @@ TEST(notnull_tests, TestNotNullConstructors)
             std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
 
         int* pi = nullptr;
-        EXPECT_DEATH((not_null<decltype(pi)>(pi)), deathstring);
+        EXPECT_DEATH((not_null<decltype(pi)>(pi)), expected);
     }
 
     {
@@ -214,8 +231,8 @@ TEST(notnull_tests, TestNotNullConstructors)
     {
         // from returned pointer
 
-        EXPECT_DEATH(helper(return_pointer()), deathstring);
-        EXPECT_DEATH(helper_const(return_pointer()), deathstring);
+        EXPECT_DEATH(helper(return_pointer()), expected);
+        EXPECT_DEATH(helper_const(return_pointer()), expected);
     }
 }
 
@@ -275,17 +292,18 @@ TEST(notnull_tests, TestNotNullCasting)
 
 TEST(notnull_tests, TestNotNullAssignment)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestNotNullAssignmentd";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     int i = 12;
     not_null<int*> p(&i);
     EXPECT_TRUE(helper(p));
 
     int* q = nullptr;
-    EXPECT_DEATH(p = not_null<int*>(q), deathstring);
+    EXPECT_DEATH(p = not_null<int*>(q), expected);
 }
 
 TEST(notnull_tests, TestNotNullRawPointerComparison)
@@ -434,17 +452,18 @@ TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
         EXPECT_TRUE(*x == 42);
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestNotNullConstructorTypeDeduction";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     {
         auto workaround_macro = []() {
             int* p1 = nullptr;
             const not_null x{p1};
         };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     {
@@ -452,14 +471,14 @@ TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
             const int* p1 = nullptr;
             const not_null x{p1};
         };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     {
         int* p = nullptr;
 
-        EXPECT_DEATH(helper(not_null{p}), deathstring);
-        EXPECT_DEATH(helper_const(not_null{p}), deathstring);
+        EXPECT_DEATH(helper(not_null{p}), expected);
+        EXPECT_DEATH(helper_const(not_null{p}), expected);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
@@ -495,10 +514,11 @@ TEST(notnull_tests, TestMakeNotNull)
         EXPECT_TRUE(*x == 42);
     }
 
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestMakeNotNull";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     {
         const auto workaround_macro = []() {
@@ -506,7 +526,7 @@ TEST(notnull_tests, TestMakeNotNull)
             const auto x = make_not_null(p1);
             EXPECT_TRUE(*x == 42);
         };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     {
@@ -515,21 +535,36 @@ TEST(notnull_tests, TestMakeNotNull)
             const auto x = make_not_null(p1);
             EXPECT_TRUE(*x == 42);
         };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     {
         int* p = nullptr;
 
-        EXPECT_DEATH(helper(make_not_null(p)), deathstring);
-        EXPECT_DEATH(helper_const(make_not_null(p)), deathstring);
+        EXPECT_DEATH(helper(make_not_null(p)), expected);
+        EXPECT_DEATH(helper_const(make_not_null(p)), expected);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS
     {
-        EXPECT_DEATH(make_not_null(nullptr), deathstring);
-        EXPECT_DEATH(helper(make_not_null(nullptr)), deathstring);
-        EXPECT_DEATH(helper_const(make_not_null(nullptr)), deathstring);
+        EXPECT_DEATH(make_not_null(nullptr), expected);
+        EXPECT_DEATH(helper(make_not_null(nullptr)), expected);
+        EXPECT_DEATH(helper_const(make_not_null(nullptr)), expected);
     }
 #endif
 }
+
+TEST(notnull_tests, TestStdHash)
+{
+    int x = 42;
+    int y = 99;
+    not_null<int*> nn{&x};
+    const not_null<int*> cnn{&x};
+
+    std::hash<not_null<int*>> hash_nn;
+    std::hash<int*> hash_intptr;
+
+    EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
+    EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
+    EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
+}

tests/owner_tests.cpp

@@ -20,7 +20,7 @@
 
 using namespace gsl;
 
-GSL_SUPPRESS(f.23) // NO-FORMAT: attribute
+GSL_SUPPRESS(f .23) // NO-FORMAT: attribute
 void f(int* i) { *i += 1; }
 
 TEST(owner_tests, basic_test)
@@ -34,10 +34,10 @@ TEST(owner_tests, basic_test)
 
 TEST(owner_tests, check_pointer_constraint)
 {
-    #ifdef CONFIRM_COMPILATION_ERRORS
+#ifdef CONFIRM_COMPILATION_ERRORS
     {
         owner<int> integerTest = 10;
         owner<std::shared_ptr<int>> sharedPtrTest(new int(10));
     }
-    #endif
+#endif
 }

tests/span_compatibility_tests.cpp

@@ -16,8 +16,8 @@
 
 #include <gtest/gtest.h>
 
-#include <gsl/gsl_byte> // for byte
-#include <gsl/span>     // for span, span_iterator, operator==, operator!=
+#include <gsl/byte> // for byte
+#include <gsl/span> // for span, span_iterator, operator==, operator!=
 
 #include <array>       // for array
 #include <cstddef>     // for ptrdiff_t
@@ -55,14 +55,14 @@ void ArrayConvertibilityCheck()
         EXPECT_TRUE(sp_const_nullptr_1.data() == stl_nullptr.data());
         EXPECT_TRUE(sp_const_nullptr_1.size() == 3);
 
-        span<const T* const> sp_const_nullptr_2{std::as_const(stl_nullptr)};
+        gsl::span<const T* const> sp_const_nullptr_2{std::as_const(stl_nullptr)};
         EXPECT_TRUE(sp_const_nullptr_2.data() == stl_nullptr.data());
         EXPECT_TRUE(sp_const_nullptr_2.size() == 3);
 
-        static_assert(std::is_same<decltype(span{stl_nullptr}), span<T*, 3>>::value,
+        static_assert(std::is_same<decltype(gsl::span{stl_nullptr}), gsl::span<T*, 3>>::value,
                       "std::is_same< decltype(span{stl_nullptr}), span<T*, 3>>::value");
         static_assert(
-            std::is_same<decltype(span{std::as_const(stl_nullptr)}), span<T* const, 3>>::value,
+            std::is_same<decltype(gsl::span{std::as_const(stl_nullptr)}), gsl::span<T* const, 3>>::value,
             "std::is_same< decltype(span{std::as_const(stl_nullptr)}), span<T* const, "
             "3>>::value");
     }
@@ -846,8 +846,6 @@ static_assert(!std::is_constructible<gsl::span<int, 3>, std::array<int, 500>&>::
               "!std::is_constructible<gsl::span<int, 3>, std::array<int, 500>&>");
 static_assert(!std::is_constructible<gsl::span<int, 3>, const std::array<int, 3>&>::value,
               "!std::is_constructible<gsl::span<int, 3>, const std::array<int, 3>&>");
-static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>::value,
-              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>");
 static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<int, 500>&>::value,
               "!std::is_constructible<gsl::span<int, 3>, const gsl::span<int, 500>&>");
 static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int>&>::value,
@@ -866,12 +864,8 @@ static_assert(!std::is_constructible<gsl::span<const int>, std::array<double, 3>
 static_assert(!std::is_constructible<gsl::span<const int>, const gsl::span<double, 3>&>::value,
               "!std::is_constructible<gsl::span<const int>, const gsl::span<double, 3>&>");
 
-static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>::value,
-              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>");
 static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int, 500>&>::value,
               "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int, 500>&>");
-static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>::value,
-              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>");
 static_assert(
     !std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int, 500>&>::value,
     "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int, 500>&>");
@@ -925,6 +919,14 @@ static_assert(!std::is_constructible<gsl::span<const Derived>, std::array<Base,
 static_assert(!std::is_constructible<gsl::span<const Derived>, const std::array<Base, 3>&>::value,
               "!std::is_constructible<gsl::span<const Derived>, const std::array<Base, 3>&>");
 
+// Explicit construction enabled in P1976R2
+static_assert(std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>::value,
+              "std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>");
+static_assert(std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>::value,
+              "std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>");
+static_assert(std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>::value,
+              "std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>");
+
 // no throw copy constructor
 static_assert(std::is_nothrow_copy_constructible<gsl::span<int>>::value,
               "std::is_nothrow_copy_constructible<gsl::span<int>>");

tests/span_ext_tests.cpp

@@ -16,27 +16,26 @@
 
 #include <gtest/gtest.h>
 
-#include <gsl/gsl_util> // for narrow_cast, at
-#include <gsl/span_ext> // for operator==, operator!=, make_span
+#include <gsl/span> // for span and span_ext
+#include <gsl/util> // for narrow_cast, at
 
-#include <array>       // for array
-#include <iostream>    // for cerr
-#include <vector>      // for vector
+#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
+#include "deathTestCommon.h"
 
 TEST(span_ext_test, make_span_from_pointer_length_constructor)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. from_pointer_length_constructor";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
     int arr[4] = {1, 2, 3, 4};
 
     {
@@ -49,7 +48,7 @@ TEST(span_ext_test, make_span_from_pointer_length_constructor)
 
     {
         int* p = nullptr;
-        auto s = make_span(p, narrow_cast<span<int>::size_type>(0));
+        auto s = make_span(p, narrow_cast<gsl::span<int>::size_type>(0));
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == nullptr);
     }
@@ -57,7 +56,7 @@ TEST(span_ext_test, make_span_from_pointer_length_constructor)
     {
         int* p = nullptr;
         auto workaround_macro = [=]() { make_span(p, 2); };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 }
 
@@ -88,273 +87,275 @@ TEST(span_ext_test, make_span_from_pointer_pointer_construction)
 }
 
 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};
+{
+    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(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(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]));
-     }
- }
+    {
+        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];
+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]);
-     }
+    {
+        auto s = make_span(&arr[0][0][0], 10);
+        EXPECT_TRUE(s.size() == 10);
+        EXPECT_TRUE(s.data() == &arr[0][0][0]);
+    }
 
-     delete[] arr;
- }
+    delete[] arr;
+}
 
- TEST(span_ext_test, make_span_from_std_array_constructor)
- {
-     std::array<int, 4> arr = {1, 2, 3, 4};
+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());
-     }
+    {
+        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);
+    // 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
+    {
+        gsl::span<int> s1 = make_span(arr);
 
-         static span<int> s2;
-         s2 = s1;
+        static gsl::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
-     }
- }
+#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};
+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());
-     }
- }
+    {
+        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};
+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());
-     }
- }
+    {
+        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;
+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 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());
-     }
- }
+        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_test, interop_with_gsl_at)
+{
+    int arr[5] = {1, 2, 3, 4, 5};
+    gsl::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};
+TEST(span_ext_test, iterator_free_functions)
+{
+    int a[] = {1, 2, 3, 4};
+    gsl::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(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(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(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((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.begin() == begin(s));
+    EXPECT_TRUE(s.end() == end(s));
 
-     EXPECT_TRUE(s.rbegin() == rbegin(s));
-     EXPECT_TRUE(s.rend() == rend(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.begin() == cbegin(s));
+    EXPECT_TRUE(s.end() == cend(s));
 
-     EXPECT_TRUE(s.rbegin() == crbegin(s));
-     EXPECT_TRUE(s.rend() == crend(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};
+TEST(span_ext_test, ssize_free_function)
+{
+    int a[] = {1, 2, 3, 4};
+    gsl::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)));
- }
+    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);
-     }
+#ifndef GSL_KERNEL_MODE
+TEST(span_ext_test, comparison_operators)
+{
+    {
+        gsl::span<int> s1;
+        gsl::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;
+    {
+        int arr[] = {2, 1};
+        gsl::span<int> s1 = arr;
+        gsl::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);
-     }
+        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
+    {
+        int arr[] = {2, 1}; // bigger
 
-         span<int> s1;
-         span<int> s2 = arr;
+        gsl::span<int> s1;
+        gsl::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);
-     }
+        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;
+    {
+        int arr1[] = {1, 2};
+        int arr2[] = {1, 2};
+        gsl::span<int> s1 = arr1;
+        gsl::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);
-     }
+        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};
+    {
+        int arr[] = {1, 2, 3};
 
-         span<int> s1 = {&arr[0], 2}; // shorter
-         span<int> s2 = arr;          // longer
+        gsl::span<int> s1 = {&arr[0], 2}; // shorter
+        gsl::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);
-     }
+        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
+    {
+        int arr1[] = {1, 2}; // smaller
+        int arr2[] = {2, 1}; // bigger
 
-         span<int> s1 = arr1;
-         span<int> s2 = arr2;
+        gsl::span<int> s1 = arr1;
+        gsl::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);
-     }
- }
+        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);
+    }
+}
+#endif // GSL_KERNEL_MODE

tests/strict_notnull_tests.cpp

@@ -14,30 +14,40 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <gsl/pointers> // for not_null, operator<, operator<=, operator>
 #include <gtest/gtest.h>
-#include <gsl/pointers>           // for not_null, operator<, operator<=, operator>
 
-namespace gsl
-{
-struct fail_fast;
-} // namespace gsl
+#include "deathTestCommon.h"
 
 using namespace gsl;
 
-GSL_SUPPRESS(f.4)  // NO-FORMAT: attribute
+namespace
+{
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool helper(not_null<int*> p) { return *p == 12; }
 
+// clang-format off
 GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool helper_const(not_null<const int*> p) { return *p == 12; }
 
+// clang-format off
 GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool strict_helper(strict_not_null<int*> p) { return *p == 12; }
 
+// clang-format off
 GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool strict_helper_const(strict_not_null<const int*> p) { return *p == 12; }
 
+#ifdef CONFIRM_COMPILATION_ERRORS
 int* return_pointer() { return nullptr; }
 const int* return_pointer_const() { return nullptr; }
+#endif
+} // namespace
 
 TEST(strict_notnull_tests, TestStrictNotNull)
 {
@@ -123,17 +133,14 @@ TEST(strict_notnull_tests, TestStrictNotNull)
 }
 
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
-namespace
-{
-static constexpr char deathstring[] = "Expected Death";
-}
 
 TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestStrictNotNullConstructorTypeDeduction";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     {
         int i = 42;
@@ -161,7 +168,7 @@ TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
             int* p1 = nullptr;
             const strict_not_null x{p1};
         };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     {
@@ -169,14 +176,14 @@ TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
             const int* p1 = nullptr;
             const strict_not_null x{p1};
         };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     {
         int* p = nullptr;
 
-        EXPECT_DEATH(helper(strict_not_null{p}), deathstring);
-        EXPECT_DEATH(helper_const(strict_not_null{p}), deathstring);
+        EXPECT_DEATH(helper(strict_not_null{p}), expected);
+        EXPECT_DEATH(helper_const(strict_not_null{p}), expected);
     }
 
 #ifdef CONFIRM_COMPILATION_ERRORS

tests/strided_span_tests.cpp

@@ -1,790 +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 <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_...
-
-#include <iostream>    // for size_t
-#include <iterator>    // for begin, end
-#include <numeric>     // for iota
-#include <type_traits> // for integral_constant<>::value, is_convertible
-#include <vector>      // for vector
-
-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++;
-    }
-}
-
-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];
-
-    const auto av = as_multi_span(a);
-    const auto sub = av.section({15, 0, 0}, gsl::multi_span_index<3>{2, 2, 2});
-    const auto subsub = sub.section({1, 0, 0}, gsl::multi_span_index<3>{1, 1, 1});
-    (void) subsub;
-}
-
-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});
-    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});
-    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));
-}
-
-TEST(strided_span_tests, strided_span_constructors)
-{
-    // 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
-        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
-        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
-        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);
-    }
-
-    // EXPECT_TRUE multi_span constructor
-    {
-        int arr[] = {1, 2};
-
-        // From non-cv-qualified source
-        {
-            const multi_span<int> src = arr;
-
-            strided_span<int, 1> sav{src, {2, 1}};
-            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 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}};
-#else
-            strided_span<const int, 1> sav_c{multi_span<const int>{src},
-                                             strided_bounds<1>{2, 1}};
-#endif
-            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 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
-            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 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
-            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
-        {
-            const multi_span<const int> src{arr};
-
-            strided_span<const int, 1> sav_c{src, {2, 1}};
-            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 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
-
-            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
-        {
-            const multi_span<volatile int> src{arr};
-
-            strided_span<volatile int, 1> sav_v{src, {2, 1}};
-            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 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
-            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
-        {
-            const multi_span<const volatile int> src{arr};
-
-            strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
-            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);
-        }
-    }
-
-    // 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};
-        EXPECT_TRUE(av2[1] == 5);
-
-        static_assert(
-            std::is_convertible<const multi_span<int, 2>, multi_span<const int, 2>>::value,
-            "ctor is not implicit!");
-
-        const strided_span<int, 1> src{arr, {2, 1}};
-        strided_span<const int, 1> sav{src};
-        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!");
-    }
-
-    // EXPECT_TRUE copy constructor
-    {
-        int arr1[2] = {3, 4};
-        const strided_span<int, 1> src1{arr1, {2, 1}};
-        strided_span<int, 1> sav1{src1};
-
-        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};
-        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 const-casting assignment operator
-    {
-        int arr1[2] = {1, 2};
-        int arr2[6] = {3, 4, 5, 6, 7, 8};
-
-        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);
-        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);
-    }
-
-    // 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);
-        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);
-        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);
-    }
-}
-
-TEST(strided_span_tests, strided_span_slice)
-{
-    std::vector<int> data(5 * 10);
-    std::iota(begin(data), end(data), 0);
-    const multi_span<int, 5, 10> src =
-        as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>());
-
-    const strided_span<int, 2> sav{src, {{5, 10}, {10, 1}}};
-#ifdef CONFIRM_COMPILATION_ERRORS
-    const strided_span<const int, 2> csav{{src}, {{5, 10}, {10, 1}}};
-#endif
-    const strided_span<const int, 2> csav{multi_span<const int, 5, 10>{src},
-                                          {{5, 10}, {10, 1}}};
-
-    strided_span<int, 1> sav_sl = sav[2];
-    EXPECT_TRUE(sav_sl[0] == 20);
-    EXPECT_TRUE(sav_sl[9] == 29);
-
-    strided_span<const int, 1> csav_sl = sav[3];
-    EXPECT_TRUE(csav_sl[0] == 30);
-    EXPECT_TRUE(csav_sl[9] == 39);
-
-    EXPECT_TRUE(sav[4][0] == 40);
-    EXPECT_TRUE(sav[4][9] == 49);
-}
-
-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
-    // (aka. "FORTRAN" layout).
-
-    int cm_array[3 * 5] = {1, 4, 7, 10, 13, 2, 5, 8, 11, 14, 3, 6, 9, 12, 15};
-    strided_span<int, 2> cm_sav{cm_array, {{5, 3}, {1, 5}}};
-
-    // Accessing elements
-    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];
-
-    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});
-
-    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));
-}
-
-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
-
-        EXPECT_DEATH(av.section(0, 0)[0], deathstring);
-        EXPECT_DEATH(av.section(1, 0)[0], deathstring);
-        EXPECT_DEATH(av.section(1, 1)[1], deathstring);
-
-        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}, {}}};
-        EXPECT_TRUE(sav[0] == 0);
-        EXPECT_TRUE(sav[3] == 0);
-        EXPECT_DEATH(sav[4], deathstring);
-    }
-
-    {
-        // zero extent
-        strided_span<int, 1> sav{av, {{}, {1}}};
-        EXPECT_DEATH(sav[0], deathstring);
-    }
-
-    {
-        // zero extent and stride
-        strided_span<int, 1> sav{av, {{}, {}}};
-        EXPECT_DEATH(sav[0], deathstring);
-    }
-
-    {
-        // strided array ctor with matching strided bounds
-        strided_span<int, 1> sav{arr, {4, 1}};
-        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}};
-        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}};
-        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
-        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
-        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
-        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
-    {
-        strided_span<int, 1> sav0{av.data(), {3, 2}};
-        strided_span<int, 1> sav1{arr, {1}};
-        strided_span<int, 1> sav2{arr, {1, 1, 1}};
-        strided_span<int, 1> sav3{av, {1}};
-        strided_span<int, 1> sav4{av, {1, 1, 1}};
-        strided_span<int, 2> sav5{av.as_multi_span(dim<2>(), dim<2>()), {1}};
-        strided_span<int, 2> sav6{av.as_multi_span(dim<2>(), dim<2>()), {1, 1, 1}};
-        strided_span<int, 2> sav7{av.as_multi_span(dim<2>(), dim<2>()),
-                                  {{1, 1}, {1, 1}, {1, 1}}};
-
-        multi_span_index<1> index{0, 1};
-        strided_span<int, 1> sav8{arr, {1, {1, 1}}};
-        strided_span<int, 1> sav9{arr, {{1, 1}, {1, 1}}};
-        strided_span<int, 1> sav10{av, {1, {1, 1}}};
-        strided_span<int, 1> sav11{av, {{1, 1}, {1, 1}}};
-        strided_span<int, 2> sav12{av.as_multi_span(dim<2>(), dim<2>()), {{1}, {1}}};
-        strided_span<int, 2> sav13{av.as_multi_span(dim<2>(), dim<2>()), {{1}, {1, 1, 1}}};
-        strided_span<int, 2> sav14{av.as_multi_span(dim<2>(), dim<2>()), {{1, 1, 1}, {1}}};
-    }
-#endif
-}
-
-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
-        strided_span<long, 1> lsav1 = sav.as_strided_span<long, 1>();
-#endif
-    }
-    {
-        strided_span<int, 1> sav{av, {av.size() / 2, 2}};
-#ifdef CONFIRM_COMPILATION_ERRORS
-        strided_span<long, 1> lsav1 = sav.as_strided_span<long, 1>();
-#endif
-    }
-
-    multi_span<const byte, dynamic_range> bytes = as_bytes(av);
-
-    // retype strided array with regular strides - from raw data
-    {
-        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>();
-        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
-    {
-        strided_bounds<2> bounds{{2, bytes.size() / 4}, {bytes.size() / 2, 1}};
-        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};
-        strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
-        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
-    {
-        strided_bounds<2> bounds{{4, 2}, {4, 1}};
-        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};
-        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
-    }
-
-    // retype strided array with not enough elements - strides are too small
-    {
-        strided_bounds<2> bounds{{4, 2}, {2, 1}};
-        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};
-        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
-    }
-
-    // retype strided array with not enough elements - last dimension does not divide by the new
-    // typesize
-    {
-        strided_bounds<2> bounds{{2, 6}, {4, 1}};
-        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};
-        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
-    }
-
-    // retype strided array with not enough elements - strides does not divide by the new
-    // typesize
-    {
-        strided_bounds<2> bounds{{2, 1}, {6, 1}};
-        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};
-        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};
-        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};
-        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
-    }
-}
-
-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}};
-
-        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;
-            EXPECT_TRUE(false);
-        }
-    }
-
-    {
-        strided_span<int, 1> empty_sav{nullptr, 0, {0, 1}};
-
-        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;
-            EXPECT_TRUE(false);
-        }
-    }
-}
-
-TEST(strided_span_tests, strided_span_section_iteration)
-{
-    int arr[8] = {4, 0, 5, 1, 6, 2, 7, 3};
-
-    // static bounds
-    {
-        multi_span<int, 8> av(arr, 8);
-        iterate_every_other_element(av);
-    }
-
-    // dynamic bounds
-    {
-        multi_span<int, dynamic_range> av(arr, 8);
-        iterate_every_other_element(av);
-    }
-}
-
-TEST(strided_span_tests, dynamic_strided_span_section_iteration)
-{
-    auto arr = new int[8];
-    for (int i = 0; i < 4; ++i) {
-        arr[2 * i] = 4 + i;
-        arr[2 * i + 1] = i;
-    }
-
-    auto av = as_multi_span(arr, 8);
-    iterate_every_other_element(av);
-
-    delete[] arr;
-}
-
-TEST(strided_span_tests, strided_span_section_iteration_3d)
-{
-    int arr[3][4][2]{};
-    for (auto i = 0; i < 3; ++i) {
-        for (auto j = 0; j < 4; ++j)
-            for (auto k = 0; k < 2; ++k) arr[i][j][k] = 8 * i + 2 * j + k;
-    }
-
-    {
-        multi_span<int, 3, 4, 2> av = arr;
-        iterate_second_slice(av);
-    }
-}
-
-TEST(strided_span_tests, dynamic_strided_span_section_iteration_3d)
-{
-    const auto height = 12, width = 2;
-    const auto size = height * width;
-
-    auto arr = new int[static_cast<std::size_t>(size)];
-    for (auto i = 0; i < size; ++i) {
-        arr[i] = i;
-    }
-
-    {
-        auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<2>());
-        iterate_second_slice(av);
-    }
-
-    {
-        auto av = as_multi_span(as_multi_span(arr, 24), dim(3), dim<4>(), dim<2>());
-        iterate_second_slice(av);
-    }
-
-    {
-        auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim(4), dim<2>());
-        iterate_second_slice(av);
-    }
-
-    {
-        auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim(2));
-        iterate_second_slice(av);
-    }
-    delete[] arr;
-}
-
-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
-    {
-        int a;
-        int b;
-        int c;
-    };
-
-    X arr[4] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}};
-
-    int s = sizeof(int) / sizeof(byte);
-    auto d2 = 3 * s;
-    auto d1 = narrow_cast<int>(sizeof(int)) * 12 / d2;
-
-    // convert to 4x12 array of bytes
-    auto av = as_multi_span(as_bytes(as_multi_span(&arr[0], 4)), dim(d1), dim(d2));
-
-    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],
-                                                   // arr[0].c[3] } , { arr[1].c[0], ... } , ...
-                                                   // }
-
-    // convert to array 4x1 array of integers
-    auto cs = section.as_strided_span<int>(); // { { arr[0].c }, {arr[1].c } , ... }
-
-    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{
-        {cs.bounds().index_bounds()[1], cs.bounds().index_bounds()[0]},
-        {cs.bounds().strides()[1], cs.bounds().strides()[0]}};
-
-    strided_span<int, 2> transposed{cs.data(), cs.bounds().total_size(), reverse_bounds};
-
-    // slice to get a one-dimensional array of c's
-    strided_span<int, 1> result = transposed[0];
-
-    EXPECT_TRUE(result.bounds().index_bounds()[0] == 4);
-    EXPECT_DEATH(result.bounds().index_bounds()[1], deathstring);
-
-    int i = 0;
-    for (auto& num : result) {
-        EXPECT_TRUE(num == arr[i].c);
-        i++;
-    }
-}

tests/string_span_tests.cpp

@@ -16,7 +16,7 @@
 
 #include <gtest/gtest.h>
 
-#include <gsl/gsl_assert>  // for Expects, fail_fast (ptr only)
+#include <gsl/assert>      // for Expects, fail_fast (ptr only)
 #include <gsl/pointers>    // for owner
 #include <gsl/span>        // for span, dynamic_extent
 #include <gsl/string_span> // for basic_string_span, operator==, ensure_z
@@ -28,13 +28,10 @@
 #include <type_traits> // for remove_reference<>::type
 #include <vector>      // for vector, allocator
 
-using namespace std;
+#include "deathTestCommon.h"
+
 using namespace gsl;
 
-namespace
-{
-static constexpr char deathstring[] = "Expected Death";
-}
 // Generic string functions
 
 namespace generic
@@ -76,8 +73,7 @@ T create()
 
 template <class T>
 void use(basic_string_span<T, gsl::dynamic_extent>)
-{
-}
+{}
 #endif
 
 czstring_span<> CreateTempName(string_span<> span)
@@ -85,7 +81,8 @@ czstring_span<> CreateTempName(string_span<> span)
     Expects(span.size() > 1);
 
     std::size_t last = 0;
-    if (span.size() > 4) {
+    if (span.size() > 4)
+    {
         span[0] = 't';
         span[1] = 'm';
         span[2] = 'p';
@@ -102,7 +99,8 @@ cwzstring_span<> CreateTempNameW(wstring_span<> span)
     Expects(span.size() > 1);
 
     std::size_t last = 0;
-    if (span.size() > 4) {
+    if (span.size() > 4)
+    {
         span[0] = L't';
         span[1] = L'm';
         span[2] = L'p';
@@ -119,7 +117,8 @@ cu16zstring_span<> CreateTempNameU16(u16string_span<> span)
     Expects(span.size() > 1);
 
     std::size_t last = 0;
-    if (span.size() > 4) {
+    if (span.size() > 4)
+    {
         span[0] = u't';
         span[1] = u'm';
         span[2] = u'p';
@@ -136,7 +135,8 @@ cu32zstring_span<> CreateTempNameU32(u32string_span<> span)
     Expects(span.size() > 1);
 
     std::size_t last = 0;
-    if (span.size() > 4) {
+    if (span.size() > 4)
+    {
         span[0] = U't';
         span[1] = U'm';
         span[2] = U'p';
@@ -950,10 +950,11 @@ TEST(string_span_tests, Conversion)
 
 TEST(string_span_tests, zstring)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. zstring";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     // create zspan from zero terminated string
     {
@@ -973,7 +974,7 @@ TEST(string_span_tests, zstring)
         buf[0] = 'a';
 
         auto workaround_macro = [&]() { const zstring_span<> zspan({buf, 1}); };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     // usage scenario: create zero-terminated temp file name and pass to a legacy API
@@ -981,8 +982,9 @@ TEST(string_span_tests, zstring)
         char buf[10];
 
         auto name = CreateTempName({buf, 10});
-        if (!name.empty()) {
-            czstring<> str = name.assume_z();
+        if (!name.empty())
+        {
+            czstring str = name.assume_z();
             EXPECT_TRUE(generic::strlen(str) == 3);
             EXPECT_TRUE(*(str + 3) == '\0');
         }
@@ -991,10 +993,11 @@ TEST(string_span_tests, zstring)
 
 TEST(string_span_tests, wzstring)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. wzstring";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     // create zspan from zero terminated string
     {
@@ -1014,7 +1017,7 @@ TEST(string_span_tests, wzstring)
         buf[0] = L'a';
 
         const auto workaround_macro = [&]() { const wzstring_span<> zspan({buf, 1}); };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     // usage scenario: create zero-terminated temp file name and pass to a legacy API
@@ -1022,8 +1025,9 @@ TEST(string_span_tests, wzstring)
         wchar_t buf[10];
 
         const auto name = CreateTempNameW({buf, 10});
-        if (!name.empty()) {
-            cwzstring<> str = name.assume_z();
+        if (!name.empty())
+        {
+            cwzstring str = name.assume_z();
             EXPECT_TRUE(generic::strnlen(str, 10) == 3);
             EXPECT_TRUE(*(str + 3) == L'\0');
         }
@@ -1032,10 +1036,11 @@ TEST(string_span_tests, wzstring)
 
 TEST(string_span_tests, u16zstring)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. u16zstring";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     // create zspan from zero terminated string
     {
@@ -1055,7 +1060,7 @@ TEST(string_span_tests, u16zstring)
         buf[0] = u'a';
 
         const auto workaround_macro = [&]() { const u16zstring_span<> zspan({buf, 1}); };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     // usage scenario: create zero-terminated temp file name and pass to a legacy API
@@ -1063,8 +1068,9 @@ TEST(string_span_tests, u16zstring)
         char16_t buf[10];
 
         const auto name = CreateTempNameU16({buf, 10});
-        if (!name.empty()) {
-            cu16zstring<> str = name.assume_z();
+        if (!name.empty())
+        {
+            cu16zstring str = name.assume_z();
             EXPECT_TRUE(generic::strnlen(str, 10) == 3);
             EXPECT_TRUE(*(str + 3) == L'\0');
         }
@@ -1073,10 +1079,11 @@ TEST(string_span_tests, u16zstring)
 
 TEST(string_span_tests, u32zstring)
 {
-    std::set_terminate([] {
+    const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. u31zstring";
         std::abort();
     });
+    const auto expected = GetExpectedDeathString(terminateHandler);
 
     // create zspan from zero terminated string
     {
@@ -1096,7 +1103,7 @@ TEST(string_span_tests, u32zstring)
         buf[0] = u'a';
 
         const auto workaround_macro = [&]() { const u32zstring_span<> zspan({buf, 1}); };
-        EXPECT_DEATH(workaround_macro(), deathstring);
+        EXPECT_DEATH(workaround_macro(), expected);
     }
 
     // usage scenario: create zero-terminated temp file name and pass to a legacy API
@@ -1104,8 +1111,9 @@ TEST(string_span_tests, u32zstring)
         char32_t buf[10];
 
         const auto name = CreateTempNameU32({buf, 10});
-        if (!name.empty()) {
-            cu32zstring<> str = name.assume_z();
+        if (!name.empty())
+        {
+            cu32zstring str = name.assume_z();
             EXPECT_TRUE(generic::strnlen(str, 10) == 3);
             EXPECT_TRUE(*(str + 3) == L'\0');
         }

tests/utils_tests.cpp

@@ -16,14 +16,15 @@
 
 #include <gtest/gtest.h>
 
-#include <gsl/gsl_util> // for narrow, finally, narrow_cast, narrowing_e...
-
 #include <algorithm>   // for move
+#include <complex>
+#include <cstddef>     // for std::ptrdiff_t
 #include <functional>  // for reference_wrapper, _Bind_helper<>::type
+#include <gsl/narrow>  // for narrow, narrowing_error
+#include <gsl/util>    // finally, narrow_cast
 #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;
 
@@ -32,8 +33,7 @@ namespace
 void f(int& i) { i += 1; }
 static int j = 0;
 void g() { j += 1; }
-}
-
+} // namespace
 
 TEST(utils_tests, sanity_check_for_gsl_index_typedef)
 {
@@ -70,6 +70,28 @@ TEST(utils_tests, finally_lambda_move)
     EXPECT_TRUE(i == 1);
 }
 
+TEST(utils_tests, finally_const_lvalue_lambda)
+{
+    int i = 0;
+    {
+        const auto const_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(const_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_mutable_lvalue_lambda)
+{
+    int i = 0;
+    {
+        auto mutable_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(mutable_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
 TEST(utils_tests, finally_function_with_bind)
 {
     int i = 0;
@@ -101,6 +123,7 @@ TEST(utils_tests, narrow_cast)
     EXPECT_TRUE(uc == 44);
 }
 
+#ifndef GSL_KERNEL_MODE
 TEST(utils_tests, narrow)
 {
     int n = 120;
@@ -123,7 +146,8 @@ TEST(utils_tests, narrow)
     n = -42;
     EXPECT_THROW(narrow<unsigned>(n), narrowing_error);
 
-#if GSL_CONSTEXPR_NARROW
-    static_assert(narrow<char>(120) == 120, "Fix GSL_CONSTEXPR_NARROW");
-#endif
+    EXPECT_TRUE(
+        narrow<std::complex<float>>(std::complex<double>(4, 2)) == std::complex<float>(4, 2));
+    EXPECT_THROW(narrow<std::complex<float>>(std::complex<double>(4.2)), narrowing_error);
 }
+#endif // GSL_KERNEL_MODE