MSVC warning workaround for empty_value

Reworked extra package installation and added explicit specification
of external package sources. Moved some common constants to environment
variables. Removed installation of unneeded packages in the containers.

.github/workflows/ci.yml

@@ -0,0 +1,523 @@
+# Copyright 2020-2021 Peter Dimov
+# Copyright 2021 Andrey Semashev
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  GIT_FETCH_JOBS: 8
+  NET_RETRY_COUNT: 5
+  DEFAULT_BUILD_VARIANT: debug,release
+
+jobs:
+  posix:
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux, gcc
+          - toolset: gcc-4.4
+            cxxstd: "98,0x"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - g++-4.4
+            sources:
+              - "ppa:ubuntu-toolchain-r/test"
+          - toolset: gcc-4.6
+            cxxstd: "03,0x"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - g++-4.6
+            sources:
+              - "ppa:ubuntu-toolchain-r/test"
+          - toolset: gcc-4.7
+            cxxstd: "03,11"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - g++-4.7
+          - toolset: gcc-4.8
+            cxxstd: "03,11"
+            os: ubuntu-18.04
+            install:
+              - g++-4.8
+          - toolset: gcc-4.9
+            cxxstd: "03,11"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - g++-4.9
+          - toolset: gcc-5
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - g++-5
+          - toolset: gcc-6
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install:
+              - g++-6
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install:
+              - g++-7
+          - toolset: gcc-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            install:
+              - g++-8
+          - toolset: gcc-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            install:
+              - g++-9
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - g++-10
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - g++-11
+            sources:
+              - "ppa:ubuntu-toolchain-r/test"
+          - name: UBSAN
+            toolset: gcc-11
+            cxxstd: "03,11,14,17,20"
+            ubsan: 1
+            os: ubuntu-20.04
+            install:
+              - g++-11
+            sources:
+              - "ppa:ubuntu-toolchain-r/test"
+
+          # Linux, clang
+          - toolset: clang
+            compiler: clang++-3.5
+            cxxstd: "03,11"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - clang-3.5
+          - toolset: clang
+            compiler: clang++-3.6
+            cxxstd: "03,11,14"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - clang-3.6
+          - toolset: clang
+            compiler: clang++-3.7
+            cxxstd: "03,11,14"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - clang-3.7
+          - toolset: clang
+            compiler: clang++-3.8
+            cxxstd: "03,11,14"
+            os: ubuntu-20.04
+            container: ubuntu:16.04
+            install:
+              - clang-3.8
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
+            install:
+              - clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
+            install:
+              - clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install:
+              - clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install:
+              - clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install:
+              - clang-7
+          # Note: clang-8 does not fully support C++20, so it is not compatible with libstdc++-8 in this mode
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            install:
+              - clang-8
+              - g++-7
+            gcc_toolchain: 7
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install:
+              - clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-10
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-11
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-12
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+            os: ubuntu-20.04
+            install:
+              - clang-12
+              - libc++-12-dev
+              - libc++abi-12-dev
+          - name: UBSAN
+            toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+            ubsan: 1
+            os: ubuntu-20.04
+            install:
+              - clang-12
+              - libc++-12-dev
+              - libc++abi-12-dev
+
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-10.15
+
+          - name: CMake tests
+            cmake_tests: 1
+            os: ubuntu-20.04
+
+    timeout-minutes: 120
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    steps:
+      - name: Setup environment
+        run: |
+            if [ -f "/etc/debian_version" ]
+            then
+                echo "DEBIAN_FRONTEND=noninteractive" >> $GITHUB_ENV
+                export DEBIAN_FRONTEND=noninteractive
+            fi
+            if [ -n "${{matrix.container}}" ]
+            then
+                echo "GHA_CONTAINER=${{matrix.container}}" >> $GITHUB_ENV
+                if [ -f "/etc/debian_version" ]
+                then
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ python python3 git cmake
+                fi
+            fi
+            git config --global pack.threads 0
+
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+            SOURCE_KEYS=(${{join(matrix.source_keys, ' ')}})
+            SOURCES=(${{join(matrix.sources, ' ')}})
+            for key in "${SOURCE_KEYS[@]}"
+            do
+                for i in {1..$NET_RETRY_COUNT}
+                do
+                    wget -O - "$key" | sudo apt-key add - && break || sleep 2
+                done
+            done
+            if [ ${#SOURCES[@]} -gt 0 ]
+            then
+                APT_ADD_REPO_COMMON_ARGS=("-y")
+                APT_ADD_REPO_HAS_SOURCE_ARGS=0
+                SOFTWARE_PROPERTIES_VERSION="$(dpkg-query --showformat='${Version}' --show software-properties-common)"
+                if dpkg --compare-versions "$SOFTWARE_PROPERTIES_VERSION" ge "0.96.24.20"
+                then
+                    APT_ADD_REPO_COMMON_ARGS+=("-n")
+                fi
+                if dpkg --compare-versions "$SOFTWARE_PROPERTIES_VERSION" ge "0.98.10"
+                then
+                    APT_ADD_REPO_HAS_SOURCE_ARGS=1
+                fi
+                for source in "${SOURCES[@]}"
+                do
+                    for i in {1..$NET_RETRY_COUNT}
+                    do
+                        APT_ADD_REPO_ARGS=("${APT_ADD_REPO_COMMON_ARGS[@]}")
+                        if [ $APT_ADD_REPO_HAS_SOURCE_ARGS -ne 0 ]
+                        then
+                            case "$source" in
+                            "ppa:"*)
+                                APT_ADD_REPO_ARGS+=("-P")
+                                ;;
+                            "deb "*)
+                                APT_ADD_REPO_ARGS+=("-S")
+                                ;;
+                            *)
+                                APT_ADD_REPO_ARGS+=("-U")
+                                ;;
+                            esac
+                        fi
+                        APT_ADD_REPO_ARGS+=("$source")
+                        sudo -E apt-add-repository "${APT_ADD_REPO_ARGS[@]}" && break || sleep 2
+                    done
+                done
+            fi
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y ${{join(matrix.install, ' ')}}
+
+      - name: Setup GCC Toolchain
+        if: matrix.gcc_toolchain
+        run: |
+            GCC_TOOLCHAIN_ROOT="$HOME/gcc-toolchain"
+            echo "GCC_TOOLCHAIN_ROOT=\"$GCC_TOOLCHAIN_ROOT\"" >> $GITHUB_ENV
+            MULTIARCH_TRIPLET="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
+            mkdir -p "$GCC_TOOLCHAIN_ROOT"
+            ln -s /usr/include "$GCC_TOOLCHAIN_ROOT/include"
+            ln -s /usr/bin "$GCC_TOOLCHAIN_ROOT/bin"
+            mkdir -p "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET"
+            ln -s "/usr/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}" "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}"
+
+      - name: Setup Boost
+        run: |
+            echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+            LIBRARY=${GITHUB_REPOSITORY#*/}
+            echo LIBRARY: $LIBRARY
+            echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+            echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+            echo GITHUB_REF: $GITHUB_REF
+            REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+            REF=${REF#refs/heads/}
+            echo REF: $REF
+            BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+            echo BOOST_BRANCH: $BOOST_BRANCH
+            BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
+            echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
+            echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
+            GIT_VERSION="$(git --version | sed -e 's/git version //')"
+            GIT_HAS_JOBS=1
+            if [ -f "/etc/debian_version" ]
+            then
+                if $(dpkg --compare-versions "$GIT_VERSION" lt 2.8.0)
+                then
+                    GIT_HAS_JOBS=0
+                fi
+            else
+                declare -a GIT_VER=(${GIT_VERSION//./ })
+                declare -a GIT_MIN_VER=(2 8 0)
+                for ((i=0; i<${#GIT_VER[@]}; i++))
+                do
+                    if [ -z "${GIT_MIN_VER[i]}" ]
+                    then
+                        GIT_MIN_VER[i]=0
+                    fi
+                    if [ "${GIT_VER[i]}" -lt "${GIT_MIN_VER[i]}" ]
+                    then
+                        GIT_HAS_JOBS=0
+                        break
+                    fi
+                done
+            fi
+            if [ "$GIT_HAS_JOBS" -ne 0 ]
+            then
+                GIT_ARGS="--jobs $GIT_FETCH_JOBS"
+            fi
+            cd ..
+            git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root"
+            cd boost-root
+            mkdir -p libs/$LIBRARY
+            cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+            git submodule init tools/boost_install
+            git submodule init libs/headers
+            git submodule init tools/build
+            git submodule init tools/cmake
+            git submodule init libs/assert
+            git submodule init libs/config
+            git submodule init libs/static_assert
+            git submodule init libs/throw_exception
+            git submodule init libs/type_traits
+            git submodule update $GIT_ARGS
+            if [ -z "${{matrix.cmake_tests}}" ]
+            then
+                ./bootstrap.sh
+                ./b2 headers
+                if [ -n "${{matrix.compiler}}" -o -n "$GCC_TOOLCHAIN_ROOT" ]
+                then
+                    echo -n "using ${{matrix.toolset}} : : ${{matrix.compiler}}" > ~/user-config.jam
+                    if [ -n "$GCC_TOOLCHAIN_ROOT" ]
+                    then
+                        echo -n " : <compileflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" <linkflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam
+                    fi
+                    echo " ;" >> ~/user-config.jam
+                fi
+            fi
+
+      - name: Run tests
+        if: matrix.cmake_tests == ''
+        run: |
+            cd ../boost-root
+            B2_ARGS=("-j" "$BUILD_JOBS" "toolset=${{matrix.toolset}}" "cxxstd=${{matrix.cxxstd}}")
+            if [ -n "${{matrix.build_variant}}" ]
+            then
+                B2_ARGS+=("variant=${{matrix.build_variant}}")
+            else
+                B2_ARGS+=("variant=$DEFAULT_BUILD_VARIANT")
+            fi
+            if [ -n "${{matrix.threading}}" ]
+            then
+                B2_ARGS+=("threading=${{matrix.threading}}")
+            fi
+            if [ -n "${{matrix.ubsan}}" ]
+            then
+                export UBSAN_OPTIONS="print_stacktrace=1"
+                B2_ARGS+=("cxxflags=-fsanitize=undefined -fno-sanitize-recover=undefined" "linkflags=-fsanitize=undefined -fuse-ld=gold" "define=UBSAN=1" "debug-symbols=on" "visibility=global")
+            fi
+            if [ -n "${{matrix.cxxflags}}" ]
+            then
+                B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
+            fi
+            if [ -n "${{matrix.linkflags}}" ]
+            then
+                B2_ARGS+=("linkflags=${{matrix.linkflags}}")
+            fi
+            B2_ARGS+=("libs/$LIBRARY/test")
+            ./b2 "${B2_ARGS[@]}"
+
+      - name: Run CMake tests
+        if: matrix.cmake_tests != ''
+        run: |
+            cd ../boost-root
+            mkdir __build_cmake_test__ && cd __build_cmake_test__
+            cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=$LIBRARY ..
+            cmake --build . --target tests
+            ctest --output-on-failure
+
+      - name: Run CMake subdir tests
+        if: matrix.cmake_tests != ''
+        run: |
+            cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+            mkdir __build_cmake_subdir_test__ && cd __build_cmake_subdir_test__
+            cmake ..
+            cmake --build .
+            cmake --build . --target check
+
+      - name: Run CMake install tests
+        if: matrix.cmake_tests != ''
+        run: |
+            cd ../boost-root
+            mkdir __build_cmake_install_test__ && cd __build_cmake_install_test__
+            cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+            cmake --build . --target install
+            cd ../libs/$LIBRARY/test/cmake_install_test
+            mkdir __build_cmake_install_test__ && cd __build_cmake_install_test__
+            cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+            cmake --build .
+            cmake --build . --target check
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.1
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2016
+          - toolset: msvc-14.2
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: gcc
+            cxxstd: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+            echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+            for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+            echo LIBRARY: %LIBRARY%
+            echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+            echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+            echo GITHUB_REF: %GITHUB_REF%
+            if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+            set BOOST_BRANCH=develop
+            for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+            echo BOOST_BRANCH: %BOOST_BRANCH%
+            cd ..
+            git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+            cd boost-root
+            xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+            git submodule init tools/boost_install
+            git submodule init libs/headers
+            git submodule init tools/build
+            git submodule init tools/cmake
+            git submodule init libs/assert
+            git submodule init libs/config
+            git submodule init libs/static_assert
+            git submodule init libs/throw_exception
+            git submodule init libs/type_traits
+            git submodule update --jobs %GIT_FETCH_JOBS%
+            cmd /c bootstrap
+            b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+            cd ../boost-root
+            b2 -j %NUMBER_OF_PROCESSORS% libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release

.travis.yml

@@ -1,412 +0,0 @@
-# Copyright 2016-2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-dist: xenial
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-9
-      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: bionic
-      compiler: g++-10
-      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-10
-          sources:
-            - sourceline: "ppa:ubuntu-toolchain-r/test"
-
-    - os: linux
-      dist: bionic
-      compiler: g++-10
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-10
-          sources:
-            - sourceline: "ppa:ubuntu-toolchain-r/test"
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
-
-    - os: linux
-      dist: trusty
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.3
-
-    - os: linux
-      dist: trusty
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.4
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-xenial-7
-
-    - os: linux
-      compiler: clang++-8
-      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-xenial-8
-
-    - os: linux
-      compiler: clang++-9
-      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-9
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      compiler: clang++-10
-      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-10
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      compiler: clang++-10
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-10
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-            - libc++abi-dev
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-            - libc++abi-dev
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode7.3
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode8.3
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode9.4
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode10.1
-
-    - os: linux
-      env: CMAKE_TEST=1
-      script:
-        - mkdir __build__ && cd __build__
-        - cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=core ..
-        - ctest --output-on-failure -R boost_core
-
-    - os: linux
-      env: CMAKE_SUBDIR_TEST=1
-      install:
-        - BOOST_BRANCH=develop
-        - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
-        - git clone -b $BOOST_BRANCH https://github.com/boostorg/config.git ../config
-        - git clone -b $BOOST_BRANCH https://github.com/boostorg/assert.git ../assert
-      script:
-      - cd test/cmake_subdir_test && mkdir __build__ && cd __build__
-      - cmake ..
-      - cmake --build .
-      - cmake --build . --target check
-
-    - os: linux
-      env: CMAKE_INSTALL_TEST=1
-      script:
-        - mkdir __build__ && cd __build__
-        - cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES="assert;config;core" -DCMAKE_INSTALL_PREFIX=~/.local ..
-        - cmake --build . --target install
-        - cd ../libs/core/test/cmake_install_test && mkdir __build__ && cd __build__
-        - cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
-        - cmake --build .
-        - cmake --build . --target check
-
-install:
-  - BOOST_BRANCH=develop
-  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
-  - cd ..
-  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule init libs/headers
-  - git submodule init libs/assert
-  - git submodule init libs/config
-  - git submodule init libs/predef
-  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
-  - git submodule init libs/type_traits
-  - git submodule init tools/build
-  - git submodule init tools/boost_install
-  - git submodule init tools/cmake
-  - git submodule update --jobs 4
-  - cp -r $TRAVIS_BUILD_DIR/* libs/core
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
-  - ./b2 -j $BUILD_JOBS libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-
-notifications:
-  email:
-    on_success: always

CMakeLists.txt

@@ -1,8 +1,9 @@
-# Copyright 2018, 2019 Peter Dimov
+# Generated by `boostdep --cmake core`
+# Copyright 2020, 2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+# https://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.5...3.20)
 
 project(boost_core VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
@@ -15,16 +16,11 @@ target_link_libraries(boost_core
   INTERFACE
     Boost::assert
     Boost::config
+    Boost::static_assert
+    Boost::throw_exception
 )
 
-if(BOOST_SUPERPROJECT_VERSION)
-
-  include(BoostInstall)
-  boost_install(TARGETS boost_core HEADER_DIRECTORY include/)
-
-endif()
-
-if(BUILD_TESTING)
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
 
   add_subdirectory(test)
 

README.md

@@ -8,12 +8,12 @@ The criteria for inclusion is that the utility component be:
 * used by other Boost libraries, and
 * not dependent on any other Boost modules except Core itself, Config, Assert, Static Assert, or Predef.
 
-### CI Status
+### Build Status
 
-Branch   | Travis | Appveyor
----------|--------|---------
-Develop  | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=develop)](https://travis-ci.org/boostorg/core) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/core)
-Master   | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=master)](https://travis-ci.org/boostorg/core) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/core)
+Branch   | GitHub Actions | AppVeyor | Test Matrix | Dependencies |
+---------|----------------|--------- | ----------- | ------------ |
+Develop  | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/filesystem/actions?query=branch%3Adevelop) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/core) | [![Tests](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/core.html) | [![Dependencies](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/core.html)
+Master   | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/filesystem/actions?query=branch%3Amaster) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/core) | [![Tests](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/core.html) | [![Dependencies](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/core.html)
 
 ### Directories
 

appveyor.yml

@@ -16,6 +16,7 @@ environment:
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
+      ADDRMD: 32
 
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-12.0,msvc-14.0
@@ -36,7 +37,7 @@ environment:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       TOOLSET: msvc-14.2
       ADDRMD: 32,64
-      CXXSTD: 14,17
+      CXXSTD: 14,17,latest
 
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\cygwin\bin;

doc/bit.qbk

@@ -0,0 +1,203 @@
+[/
+  Copyright 2020 Peter Dimov
+
+  Distributed under the Boost Software License, Version 1.0.
+
+  See accompanying file LICENSE_1_0.txt
+  or copy at http://boost.org/LICENSE_1_0.txt
+]
+
+[section:bit bit]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/bit.hpp>]
+
+The header `<boost/core/bit.hpp>` implements, in a portable way,
+the C++20 `<bit>` header.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+// bit_cast
+
+template<class To, class From>
+To bit_cast(From const& from) noexcept;
+
+// Integral powers of 2
+
+template<class T>
+constexpr bool has_single_bit(T x) noexcept;
+
+template<class T>
+constexpr T bit_ceil(T x) noexcept;
+
+template<class T>
+constexpr T bit_floor(T x) noexcept;
+
+template<class T>
+constexpr T bit_width(T x) noexcept;
+
+// Rotating
+
+template<class T>
+constexpr T rotl(T x, int s) noexcept;
+
+template<class T>
+constexpr T rotr(T x, int s) noexcept;
+
+// Counting
+
+template<class T>
+constexpr int countl_zero(T x) noexcept;
+
+template<class T>
+constexpr int countl_one(T x) noexcept;
+
+template<class T>
+constexpr int countr_zero(T x) noexcept;
+
+template<class T>
+constexpr int countr_one(T x) noexcept;
+
+template<class T>
+constexpr int popcount(T x) noexcept;
+
+// Endian
+
+enum class endian
+{
+    little = see below,
+    big = see below,
+    native = see below
+};
+
+using endian_type = endian; // portable alias for C++03 code
+
+} // namespace core
+} // namespace boost
+``
+
+Note: even though the functions are shown as `constexpr` in the synopsis, since they are implemented
+via compiler-specific intrinsics, portable code cannot generally rely on their being usable in a
+constant expression context.
+
+[endsect]
+
+[section bit_cast]
+
+`template<class To, class From> To bit_cast(From const& from) noexcept;`
+
+* *Requires:* `To` and `From` must be trivially copyable and `sizeof(To)` must be the same as `sizeof(From)`.
+* *Returns:* A value of type `To` with the storage bytes copied from `from`.
+
+[endsect]
+
+[section Integral powers of 2]
+
+`template<class T> constexpr bool has_single_bit(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type (i.e. one of `unsigned char`, `unsigned short`, `unsigned int`, `unsigned long`, `unsigned long long`).
+* *Returns:* `true` if `x` is an integral power of two, `false` otherwise. (`has_single_bit(0u)` is false.)
+
+`template<class T> constexpr T bit_ceil(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* The smallest integral power of 2 greater than or equal to `x`. If this value is not representable in `T`, behavior is undefined.
+
+`template<class T> constexpr T bit_floor(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* If `x == 0`, 0; otherwise the maximal value `y` such that `has_single_bit(y)` is `true` and `y <= x`.
+
+`template<class T> constexpr T bit_width(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* If `x == 0`, 0; otherwise one plus the base-2 logarithm of `x`, with any fractional part discarded.
+
+[endsect]
+
+[section Rotating]
+
+In the following descriptions, `N` denotes `numeric_limits<T>::digits` and `r` denotes `s % N`.
+
+`template<class T> constexpr T rotl(T x, int s) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* If `s` is negative, `rotr(x, -s)`; if `r` is 0, `x`; if `r` is positive, `(x << r) | (x >> (N - r))`.
+
+`template<class T> constexpr T rotr(T x, int s) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* If `s` is negative, `rotl(x, -s)`; if `r` is 0, `x`; if `r` is positive, `(x >> r) | (x << (N - r))`.
+
+[endsect]
+
+[section Counting]
+
+`template<class T> constexpr int countl_zero(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* The number of consecutive 0 bits in the value of `x`, starting from the most significant ("left") bit.
+
+`template<class T> constexpr int countl_one(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* The number of consecutive 1 bits in the value of `x`, starting from the most significant bit.
+
+`template<class T> constexpr int countr_zero(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* The number of consecutive 0 bits in the value of `x`, starting from the least significant ("right") bit.
+
+`template<class T> constexpr int countr_one(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* The number of consecutive 1 bits in the value of `x`, starting from the least significant bit.
+
+`template<class T> constexpr int popcount(T x) noexcept;`
+
+* *Requires:* `T` must be an unsigned integer type.
+* *Returns:* The number of 1 bits in the value of `x`.
+
+[endsect]
+
+[section Endian]
+
+Under C++11, `endian` is defined as `enum class endian` as shown in the synopsis. Under C++03, its definition is
+
+``
+namespace endian
+{
+enum type
+{
+    little = see below,
+    big = see below,
+    native = see below
+};
+}
+
+typedef endian::type endian_type;
+``
+
+The values of `endian::big` and `endian::little` are distinct. `endian::native` is equal to `endian::big` on
+big endian platforms, equal to `endian::little` on little endian platforms, and a distinct value on platforms
+that are neither.
+
+Note that you should not rely on `little` and `big` having any specific values, because the C++20 standard
+leaves these unspecified.
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/changes.qbk

@@ -0,0 +1,90 @@
+[/
+  Copyright 2021 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt)
+]
+
+[section Revision History]
+
+[section Changes in 1.78.0]
+
+* Added a generic implementation to `boost/core/cmath.hpp`, enabled when `BOOST_CORE_USE_GENERIC_CMATH`
+  is defined or when the platform does not provide the necessary facilities in `<cmath>`.
+* Added `boost::core::type_name`, a utility function that returns the name of a type as a string.
+* Added `boost::span`, a C++11 implementation of C++20's `std::span`.
+
+[endsect]
+
+[section Changes in 1.77.0]
+
+* `boost/core/uncaught_exceptions.hpp` has been modified for compatibility with Mac OS 10.4 and older.
+
+[endsect]
+
+[section Changes in 1.76.0]
+
+* Added implicit conversion between compatible reference wrappers.
+* Added `boost/core/cmath.hpp`, a portable implementation of the floating point classification functions from `<cmath>`.
+* Added `boost/core/bit.hpp`, a portable implementation of the C++20 standard header `<bit>`.
+* Fixed `BOOST_TEST_EQ`, `BOOST_TEST_NE` for character types under C++20.
+* Revised allocator access utilities (now support VS2013, and no workarounds use `allocator_traits`.)
+
+[endsect]
+
+[section Changes in 1.74.0]
+
+* Implemented the allocator access utilities which provide a replacement for `allocator_traits`
+  with individual traits and functions for each facility. They support the C++11 allocator model
+  when possible and provide a fallback for C++98 compatibility.
+* Added `BOOST_TEST_WITH` to Lightweight Test.
+
+[endsect]
+
+[section Changes in 1.71.0]
+
+* Added functions `alloc_construct`, `alloc_construct_n`, `alloc_destroy`, and `alloc_destroy_n`
+  in `<boost/core/alloc_construct.hpp>` for allocator aware and exception safe construction and
+  destruction of objects and arrays.
+* Added constexpr functions `first_scalar` in `<boost/core/first_scalar.hpp>` for obtaining a pointer
+  to the first scalar element of an array. Given a pointer of type `T*` they return a pointer of type
+  `remove_all_extents_t<T>*`.
+* Added class template `noinit_adaptor` in `<boost/core/noinit_adaptor.hpp>` which is an allocator adaptor
+  that converts any allocator into one whose `construct(ptr)` performs default initialization via placement
+  `new`, and whose `destroy(ptr)` invokes the `value_type` destructor directly.
+* Added class template `default_allocator` in `<boost/core/default_allocator.hpp>`, which can serve as a minimal
+  default allocator that has interface similar to C++20 `std::allocator`, supports configurations with disabled
+  exceptions and does not have `std` as an associated namespace. The allocator uses `operator new` and
+  `operator delete` for allocation.
+* In `<boost/core/uncaught_exceptions.hpp>` header, added workarounds for better compatibility with QNX SDP 7.0
+  when libc++/libc++abi libraries are used.
+* The `<boost/detail/sp_typeinfo.hpp>` header is now marked as deprecated and will be removed in a future release.
+  `<boost/core/typeinfo.hpp>` should be used instead.
+
+[endsect]
+
+[section Changes in 1.69.0]
+
+* Implemented `boost::empty_value`, for library authors to conveniently leverage the Empty Base Optimization to
+  store objects of potentially empty types.
+* Implemented `boost::quick_exit` to provide the C++11 standard library facility `std::quick_exit` functionality.
+* Reduced the number of statics in Lightweight Test, and employ lighter abort behavior for MSVC compilers upon
+  failure to call `boost::report_errors`.
+
+[endsect]
+
+[section Changes in 1.67.0]
+
+* Updated `to_address` and `pointer_traits` to reflect the design adopted for C++20 in
+  [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0653r2.html P0653R2].
+
+[endsect]
+
+[section Changes in 1.65.0]
+
+* Implemented `pointer_traits` for C++03 and higher, that implements
+  [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0653r0.html P0653r0].
+* Added `BOOST_TEST_GT` and `BOOST_TEST_GE` to Lightweight Test.
+
+[endsect]
+
+[endsect]

doc/cmath.qbk

@@ -0,0 +1,122 @@
+[/
+  Copyright 2018 Peter Dimov
+
+  Distributed under the Boost Software License, Version 1.0.
+
+  See accompanying file LICENSE_1_0.txt
+  or copy at http://boost.org/LICENSE_1_0.txt
+]
+
+[section:cmath cmath]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/cmath.hpp>]
+
+The header `<boost/core/cmath.hpp>` defines, in a portable way, the floating
+point classification and sign manipulation functions from C++11.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+// fpclassify return values
+
+int const fp_zero = /*unspecified*/;
+int const fp_subnormal = /*unspecified*/;
+int const fp_normal = /*unspecified*/;
+int const fp_infinite = /*unspecified*/;
+int const fp_nan = /*unspecified*/;
+
+// Classification functions
+
+template<class T> bool isfinite( T x );
+template<class T> bool isnan( T x );
+template<class T> bool isinf( T x );
+template<class T> bool isnormal( T x );
+template<class T> int fpclassify( T x );
+
+// Sign manipulation functions
+
+template<class T> bool signbit( T x );
+template<class T> T copysign( T x, T y );
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section Classification Functions]
+
+[section template<class T> bool isfinite( T x );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:* `true` when `x` is finite (not infinity or NaN), `false` otherwise.
+
+[endsect]
+
+[section template<class T> bool isnan( T x );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:* `true` when `x` is NaN, `false` otherwise.
+
+[endsect]
+
+[section template<class T> bool isinf( T x );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:* `true` when `x` is infinity, `false` otherwise.
+
+[endsect]
+
+[section template<class T> bool isnormal( T x );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:* `true` when `x` is a normal number (not zero, subnormal, infinity, or NaN), `false` otherwise.
+
+[endsect]
+
+[section template<class T> int fpclassify( T x );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:*
+  * `fp_zero` when `x` is zero;
+  * `fp_subnormal` when `x` is subnormal;
+  * `fp_infinite` when `x` is infinity;
+  * `fp_nan` when `x` is NaN;
+  * `fp_normal` otherwise.
+
+[endsect]
+
+[endsect]
+
+[section Sign Manipulation Functions]
+
+[section template<class T> bool signbit( T x );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:* `true` when `x` is negative, `false` otherwise.
+
+[endsect]
+
+[section template<class T> bool copysign( T x, T y );]
+
+* *Requires:* `T` must be `float`, `double`, or `long double`.
+* *Returns:* `x` with the sign copied from `y`.
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/core.qbk

@@ -34,14 +34,18 @@ criteria for inclusion is that the utility component be:
 * simple,
 * used by other Boost libraries, and
 * not dependent on any other Boost modules except Core
-  itself, Config, Assert, Static Assert, or Predef.
+  itself, Config, Assert, or Static Assert.
 
 [endsect]
 
+[include changes.qbk]
+
 [include addressof.qbk]
 [include allocator_access.qbk]
 [include alloc_construct.qbk]
+[include bit.qbk]
 [include checked_delete.qbk]
+[include cmath.qbk]
 [include default_allocator.qbk]
 [include demangle.qbk]
 [include empty_value.qbk]
@@ -61,7 +65,9 @@ criteria for inclusion is that the utility component be:
 [include quick_exit.qbk]
 [include ref.qbk]
 [include scoped_enum.qbk]
+[include span.qbk]
 [include swap.qbk]
 [include typeinfo.qbk]
+[include type_name.qbk]
 [include uncaught_exceptions.qbk]
 [include use_default.qbk]

doc/span.qbk

@@ -0,0 +1,404 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:span span]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+This header <boost/core/span.hpp> provides class template `span`, which is a
+view over a sequence of objects. It implements the C++20 standard library
+`std::span` facility. This implementation supports C++11 and higher.
+
+In addition to referencing the sequence of objects, the span knows the count of
+objects. There are two kinds of spans:
+
+* Dynamic size (`span<T>` or `span<T, dynamic_extent>`)
+* Static size (`span<T, N>`)
+
+Dynamic size spans have a count that can be a value known at run time. Static
+size spans have a count that must be known at compile time.
+
+[endsect]
+
+[section Examples]
+
+The following snippet shows a function to compute a SHA1 hash whose parameters
+and return type use spans.
+
+```
+auto sha1(boost::span<const unsigned char> input,
+    boost::span<unsigned char, SHA_DIGEST_LENGTH> ouput)
+{
+    SHA_CTX context;
+    SHA1_Init(&context);
+    SHA1_Update(&context, input.data(), input.size());
+    SHA1_Final(output.data(), &context);
+    return output;
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+constexpr std::size_t dynamic_extent = -1;
+
+template<class T, std::size_t E = dynamic_extent>
+class span {
+public:
+    typedef T element_type;
+    typedef std::remove_cv_t<T> value_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    typedef std::reverse_iterator<T*> reverse_iterator;
+    typedef std::reverse_iterator<const T*> const_reverse_iterator;
+
+    static constexpr std::size_t extent = E;
+
+    constexpr span() noexcept;
+
+    explicit(E != dynamic_extent)
+    template<class I>
+    constexpr span(I* f, size_type c);
+
+    explicit(E != dynamic_extent)
+    template<class I, class L>
+    constexpr span(I* f, L* l);
+
+    template<std::size_t N>
+    constexpr span(type_identity_t<T> (&a)[N]);
+
+    template<class U, std::size_t N>
+    constexpr span(std::array<U, N>& a) noexcept;
+
+    template<class U, std::size_t N>
+    constexpr span(const std::array<U, N>& a) noexcept;
+
+    explicit(E != dynamic_extent)
+    template<class R>
+    constexpr span(R&& r);
+
+    explicit(E != dynamic_extent && N == dynamic_extent)
+    template<class U, std::size_t N>
+    constexpr span(const span<U, N>& s) noexcept;
+
+    template<std::size_t C>
+    constexpr span<T, C> first() const;
+
+    template<std::size_t C>
+    constexpr span<T, C> last() const;
+
+    template<std::size_t O, std::size_t C = dynamic_extent>
+    constexpr span<T, see below> subspan() const;
+
+    constexpr span<T, dynamic_extent> first(size_type c) const;
+    constexpr span<T, dynamic_extent> last(size_type c) const;
+
+    constexpr span<T, dynamic_extent> subspan(size_type o,
+        size_type c = dynamic_extent) const;
+
+    constexpr size_type size() const noexcept;
+    constexpr size_type size_bytes() const noexcept;
+    constexpr bool empty() const noexcept;
+
+    constexpr reference operator[](size_type i) const;
+    constexpr reference front() const;
+    constexpr reference back() const;
+    constexpr pointer data() const noexcept;
+
+    constexpr iterator begin() const noexcept;
+    constexpr iterator end() const noexcept;
+    constexpr reverse_iterator rbegin() const noexcept;
+    constexpr reverse_iterator rend() const noexcept;
+    constexpr const_iterator cbegin() const noexcept;
+    constexpr const_iterator cend() const noexcept;
+    constexpr const_reverse_iterator crbegin() const noexcept;
+    constexpr const_reverse_iterator crend() const noexcept;
+
+    friend constexpr iterator begin(span s) noexcept {
+        return s.begin();
+    }
+
+    friend constexpr iterator end(span s) noexcept {
+        return s.end();
+    }
+};
+
+template<class I, class L>
+span(I*, L) -> span<I>;
+
+template<class T, std::size_t N>
+span(T(&)[N]) -> span<T, N>;
+
+template<class T, std::size_t N>
+span(std::array<T, N>&) -> span<T, N>;
+
+template<class T, std::size_t N>
+span(const std::array<T, N>&) -> span<const T, N>;
+
+template<class R>
+span(R&&) -> span<std::remove_pointer_t<decltype(std::declval<R&>().data())> >;
+
+template<class T, std::size_t E>
+span<const std::byte, E == dynamic_extent ? dynamic_extent : sizeof(T) * E>
+as_bytes(span<T, E> s) noexcept;
+
+template<class T, std::size_t E>
+span<std::byte, E == dynamic_extent ? dynamic_extent : sizeof(T) * E>
+as_writable_bytes(span<T, E> s) noexcept;
+
+} /* boost */
+```
+
+[section Constructors]
+
+[variablelist
+[[`constexpr span() noexcept;`]
+[[variablelist
+[[Constraints][`E == dynamic_extent || E == 0` is `true`.]]
+[[Postconditions][`size() == 0 && data() == nullptr`.]]]]]
+[[`explicit(E != dynamic_extent)
+template<class I>
+constexpr span(I* f, size_type c);`]
+[[variablelist
+[[Constraints]
+[`is_convertible_v<I(*)[], T(*)[]>` is `true`.]]
+[[Preconditions]
+[[itemized_list
+[`[f, f + c)` is a valid range.]
+[If `E` is not equal to `dynamic_extent`, then `c` is equal to `E`.]]]]
+[[Effects][Constructs a `span` with data `f` and size `c`.]]
+[[Throws][Nothing.]]]]]
+[[`explicit(E != dynamic_extent)
+template<class I, class L>
+constexpr span(I* f, L* l);`]
+[[variablelist
+[[Constraints]
+[`is_convertible_v<I(*)[], T(*)[]>` is `true`.]]
+[[Preconditions]
+[[itemized_list
+[If `E` is not equal to `dynamic_extent`, then `l - f` is equal to `E`.]
+[`[f, l)` is a valid range.]]]]
+[[Effects][Constructs a `span` with data `f` and size `l - f`.]]
+[[Throws][Nothing.]]]]]
+[[`template<std::size_t N>
+constexpr span(type_identity_t<T> (&a)[N]);`]
+[[variablelist
+[[Constraints][`E == dynamic_extent || E == N` is `true`.]]
+[[Effects][Constructs a `span` that is a view over the supplied array.]]
+[[Postconditions][`size() == N && data() == &a[0]` is `true`.]]]]]
+[[`template<class U, std::size_t N>
+constexpr span(std::array<U, N>& a) noexcept;`]
+[[variablelist
+[[Constraints]
+[[itemized_list
+[`E == dynamic_extent || E == N` is `true`, and]
+[`U(*)[]` is convertible to `T(*)[]`.]]]]
+[[Effects][Constructs a `span` that is a view over the supplied array.]]
+[[Postconditions][`size() == N && data() == a.data()` is `true`.]]]]]
+[[`template<class U, std::size_t N>
+constexpr span(const std::array<U, N>& a) noexcept;`]
+[[variablelist
+[[Constraints]
+[[itemized_list
+[`E == dynamic_extent || E == N` is `true`, and]
+[`U(*)[]` is convertible to `T(*)[]`.]]]]
+[[Effects][Constructs a `span` that is a view over the supplied array.]]
+[[Postconditions][`size() == N && data() == a.data()` is `true`.]]]]]
+[[`explicit(E != dynamic_extent)
+template<class R>
+constexpr span(R&& r);`]
+[[variablelist
+[[Constraints]
+[[itemized_list
+[`is_lvalue_reference_v<R> || is_const_v<T>` is `true`]
+[`remove_cvref_t<R>` is not a specialization of `span`,]
+[`remove_cvref_t<R>` is not a specialization of `array`,]
+[`is_array_v<remove_cvref_t<R>>` is `false`,]
+[`r.data()` is well-formed and
+`is_convertible_v<remove_pointer_t<decltype(declval<R&>().data())>(*)[],
+T(*)[]>` is `true`, and]
+[`r.size()` is well-formed and
+`is_convertible_v<decltype(declval<R&>().size()), size_t>` is `true`.]]]]
+[[Effects][Constructs a `span` with data `r.data()` and size `r.size()`.]]
+[[Throws][What and when r.data() and r.size() throw.]]]]]
+[[`explicit(E != dynamic_extent && N == dynamic_extent)
+template<class U, std::size_t N>
+constexpr span(const span<U, N>& s) noexcept;`]
+[[variablelist
+[[Constraints]
+[[itemized_list
+[`E == dynamic_extent || N == dynamic_extent || E == N` is `true`, and]
+[`is_convertible_v<U(*)[], T(*)[]>` is `true`.]]]]
+[[Preconditions]
+[If `E` is not equal to `dynamic_extent`, then `s.size()` is equal to `E`.]]
+[[Effects]
+[Constructs a `span` that is a view over the range
+`[s.data(), s.data() + s.size())`.]]
+[[Postconditions][`size() == s.size() && data() == s.data()`.]]]]]]
+
+[endsect]
+
+[section Subviews]
+
+[variablelist
+[[`template<std::size_t C> constexpr span<T, C> first() const;`]
+[[variablelist
+[[Mandates][`C <= E` is `true`.]]
+[[Preconditions][`C <= size()` is `true`.]]
+[[Effects]
+[Equivalent to `return R{data(), C};` where `R` is the return type.]]]]]
+[[`template<std::size_t C> constexpr span<T, C> last() const;`]
+[[variablelist
+[[Mandates][`C <= E` is `true`.]]
+[[Preconditions][`C <= size()` is `true`.]]
+[[Effects]
+[Equivalent to `return R{data() + (size() - C), C};` where `R` is the return
+type.]]]]]
+[[`template<std::size_t O, std::size_t C = dynamic_extent>
+constexpr span<T, see below> subspan() const;`]
+[[variablelist
+[[Mandates][`O <= E && (C == dynamic_extent || C <= E - O)` is `true`.]]
+[[Preconditions]
+[`O <= size() && (C == dynamic_extent || C <= size() - O)` is `true`.]]
+[[Effects]
+[Equivalent to
+`return span<T, see below>(data() + O,
+C != dynamic_extent ? C : size() - O);`.]]
+[[Remarks]
+[The second template argument of the returned span type is:
+`C != dynamic_extent ? C : (E != dynamic_extent ? E - O :
+dynamic_extent)`]]]]]
+[[`constexpr span<T, dynamic_extent> first(size_type c) const;`]
+[[variablelist
+[[Preconditions][`c <= size()` is `true`.]]
+[[Effects][Equivalent to: `return {data(), c};`]]]]]
+[[`constexpr span<T, dynamic_extent> last(size_type c) const;`]
+[[variablelist
+[[Preconditions][`c <= size()` is `true`.]]
+[[Effects][Equivalent to: `return {data() + (size() - c), c};`]]]]]
+[[`constexpr span<T, dynamic_extent> subspan(size_type o,
+size_type c = dynamic_extent) const;`]
+[[variablelist
+[[Preconditions]
+[`o <= size() && (c == dynamic_extent || o + c <= size())` is `true`.]]
+[[Effects]
+[Equivalent to:
+`return {data() + o, c == dynamic_extent ? size() - o : c};`]]]]]]
+
+[endsect]
+
+[section Observers]
+
+[variablelist
+[[`constexpr size_type size() const noexcept;`]
+[[variablelist
+[[Returns][The number of elements in the span.]]]]]
+[[`constexpr size_type size_bytes() const noexcept;`]
+[[variablelist
+[[Effects][Equivalent to: `return size() * sizeof(T);`]]]]]
+[[`constexpr bool empty() const noexcept;`]
+[[variablelist
+[[Effects][Equivalent to: `return size() == 0;`]]]]]]
+
+[endsect]
+
+[section Element access]
+
+[variablelist
+[[`constexpr reference operator[](size_type i) const;`]
+[[variablelist
+[[Preconditions][`i < size()` is `true`.]]
+[[Effects][Equivalent to: `return *(data() + i);`]]]]]
+[[`constexpr reference front() const;`]
+[[variablelist
+[[Preconditions][`empty()` is `false`.]]
+[[Effects][Equivalent to: `return *data();`]]]]]
+[[`constexpr reference back() const;`]
+[[variablelist
+[[Preconditions][`empty()` is `false`.]]
+[[Effects][Equivalent to: `return *(data() + (size() - 1);`]]]]]
+[[`constexpr pointer data() const noexcept;`]
+[[variablelist
+[[Returns][A pointer to the first element in the span.]]]]]]
+
+[endsect]
+
+[section Iterator support]
+
+[variablelist
+[[`constexpr iterator begin() const noexcept;`]
+[[variablelist
+[[Returns][A constant iterator referring to the first element in the span. If `empty()`,
+then it returns the same value as `cend()`.]]]]]
+[[`constexpr iterator end() const noexcept;`]
+[[variablelist
+[[Returns][A constant iterator which is the past-the-end value.]]]]]
+[[`constexpr reverse_iterator rbegin() const noexcept;`]
+[[variablelist
+[[Effects][Equivalent to: `return reverse_iterator(end());`]]]]]
+[[`constexpr reverse_iterator rend() const noexcept;`]
+[[variablelist
+[[Effects][Equivalent to: `return reverse_iterator(begin());`]]]]]
+[[`constexpr const_iterator cbegin() const noexcept;`]
+[[variablelist
+[[Returns]
+[A constant iterator referring to the first element in the span. If `empty()`,
+then it returns the same value as `cend()`.]]]]]
+[[`constexpr const_iterator cend() const noexcept;`]
+[[variablelist
+[[Returns][A constant iterator which is the past-the-end value.]]]]]
+[[`constexpr const_reverse_iterator crbegin() const noexcept;`]
+[[variablelist
+[[Effects][Equivalent to: `return const_reverse_iterator(cend());`]]]]]
+[[`constexpr const_reverse_iterator crend() const noexcept;`]
+[[variablelist
+[[Effects]
+[Equivalent to: `return const_reverse_iterator(cbegin());`]]]]]]
+
+[endsect]
+
+[section Views of object representation]
+
+[variablelist
+[[`template<class T, std::size_t E>
+span<const std::byte, E == dynamic_extent ? dynamic_extent : sizeof(T) * E>
+as_bytes(span<T, E> s) noexcept;`]
+[[variablelist
+[[Effects]
+[Equivalent to:
+`return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};`.]]]]]
+[[`template<class T, std::size_t E>
+span<std::byte, E == dynamic_extent ? dynamic_extent : sizeof(T) * E>
+as_writable_bytes(span<T, E> s) noexcept;`]
+[[variablelist
+[[Constraints][`is_const_v<T>` is `false`.]]
+[[Effects]
+[Equivalent to: `return R{reinterpret_cast<byte*>(s.data()), s.size_bytes()};`
+where `R` is the return type.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/string_view.qbk

@@ -0,0 +1,768 @@
+[/
+  Copyright 2021 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:string_view string_view]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/string_view.hpp>]
+
+The header `<boost/core/string_view.hpp>` defines `boost::core::string_view`,
+a portable and interoperable implementation of `std::string_view`.
+
+Unlike `boost::string_view`, `boost::core::string_view` has implicit
+conversions from and to `std::string_view`, which allows Boost libraries that
+support C++11/C++14 to use it in interfaces without forcing users to forgo the
+use of `std::string_view` in their code.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+template<class Ch> class basic_string_view
+{
+public:
+
+    // types
+
+    typedef std::char_traits<Ch> traits_type;
+    typedef Ch value_type;
+    typedef Ch* pointer;
+    typedef Ch const* const_pointer;
+    typedef Ch& reference;
+    typedef Ch const& const_reference;
+    typedef Ch const* const_iterator;
+    typedef const_iterator iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef const_reverse_iterator reverse_iterator;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    // npos
+
+    static constexpr size_type npos = static_cast<size_type>( -1 );
+
+public:
+
+    // construction and assignment
+
+    constexpr basic_string_view() noexcept;
+    constexpr basic_string_view( basic_string_view const& ) noexcept = default;
+    constexpr basic_string_view& operator=( basic_string_view const& ) noexcept & = default;
+    constexpr basic_string_view( Ch const* str ) noexcept;
+    constexpr basic_string_view( Ch const* str, size_type len ) noexcept;
+    constexpr basic_string_view( Ch const* begin, Ch const* end ) noexcept;
+    template<class A> basic_string_view( std::basic_string<Ch, std::char_traits<Ch>, A> const& str ) noexcept;
+    basic_string_view( std::basic_string_view<Ch, std::char_traits<Ch>> const& str ) noexcept;
+
+    // conversions
+
+    template<class A> operator std::basic_string<Ch, std::char_traits<Ch>, A>() const;
+    template<class Ch2> operator std::basic_string_view<Ch2>() const noexcept;
+
+    // iterator support
+
+    constexpr const_iterator begin() const noexcept;
+    constexpr const_iterator end() const noexcept;
+    constexpr const_iterator cbegin() const noexcept;
+    constexpr const_iterator cend() const noexcept;
+    constexpr const_reverse_iterator rbegin() const noexcept;
+    constexpr const_reverse_iterator rend() const noexcept;
+    constexpr const_reverse_iterator crbegin() const noexcept;
+    constexpr const_reverse_iterator crend() const noexcept;
+
+    // capacity
+
+    constexpr size_type size() const noexcept;
+    constexpr size_type length() const noexcept;
+    constexpr size_type max_size() const noexcept;
+    constexpr bool empty() const noexcept;
+
+    // element access
+
+    constexpr const_reference operator[]( size_type pos ) const noexcept;
+    constexpr const_reference at( size_type pos ) const;
+    constexpr const_reference front() const noexcept;
+    constexpr const_reference back() const noexcept;
+    constexpr const_pointer data() const noexcept;
+
+    // modifiers
+
+    constexpr void remove_prefix( size_type n ) noexcept;
+    constexpr void remove_suffix( size_type n ) noexcept;
+    constexpr void swap( basic_string_view& s ) noexcept;
+
+    // string operations
+
+    constexpr size_type copy( Ch* s, size_type n, size_type pos = 0 ) const;
+    constexpr basic_string_view substr( size_type pos = 0, size_type n = npos ) const;
+
+    // compare
+
+    constexpr int compare( basic_string_view str ) const noexcept;
+    constexpr int compare( size_type pos1, size_type n1, basic_string_view str ) const;
+    constexpr int compare( size_type pos1, size_type n1, basic_string_view str, size_type pos2, size_type n2 ) const;
+    constexpr int compare( Ch const* s ) const;
+    constexpr int compare( size_type pos1, size_type n1, Ch const* s ) const;
+    constexpr int compare( size_type pos1, size_type n1, Ch const* s, size_type n2 ) const;
+
+    // starts_with
+
+    constexpr bool starts_with( basic_string_view x ) const noexcept;
+    constexpr bool starts_with( Ch x ) const noexcept;
+    constexpr bool starts_with( Ch const* x ) const noexcept;
+
+    // ends_with
+
+    constexpr bool ends_with( basic_string_view x ) const noexcept;
+    constexpr bool ends_with( Ch x ) const noexcept;
+    constexpr bool ends_with( Ch const* x ) const noexcept;
+
+    // find
+
+    constexpr size_type find( basic_string_view str, size_type pos = 0 ) const noexcept;
+    constexpr size_type find( Ch c, size_type pos = 0 ) const noexcept;
+    constexpr size_type find( Ch const* s, size_type pos, size_type n ) const noexcept;
+    constexpr size_type find( Ch const* s, size_type pos = 0 ) const noexcept;
+
+    // rfind
+
+    constexpr size_type rfind( basic_string_view str, size_type pos = npos ) const noexcept;
+    constexpr size_type rfind( Ch c, size_type pos = npos ) const noexcept;
+    constexpr size_type rfind( Ch const* s, size_type pos, size_type n ) const noexcept;
+    constexpr size_type rfind( Ch const* s, size_type pos = npos ) const noexcept;
+
+    // find_first_of
+
+    constexpr size_type find_first_of( basic_string_view str, size_type pos = 0 ) const noexcept;
+    constexpr size_type find_first_of( Ch c, size_type pos = 0 ) const noexcept;
+    constexpr size_type find_first_of( Ch const* s, size_type pos, size_type n ) const noexcept;
+    constexpr size_type find_first_of( Ch const* s, size_type pos = 0 ) const noexcept;
+
+    // find_last_of
+
+    constexpr size_type find_last_of( basic_string_view str, size_type pos = npos ) const noexcept;
+    constexpr size_type find_last_of( Ch c, size_type pos = npos ) const noexcept;
+    constexpr size_type find_last_of( Ch const* s, size_type pos, size_type n ) const noexcept;
+    constexpr size_type find_last_of( Ch const* s, size_type pos = npos ) const noexcept;
+
+    // find_first_not_of
+
+    constexpr size_type find_first_not_of( basic_string_view str, size_type pos = 0 ) const noexcept;
+    constexpr size_type find_first_not_of( Ch c, size_type pos = 0 ) const noexcept;
+    constexpr size_type find_first_not_of( Ch const* s, size_type pos, size_type n ) const noexcept;
+    constexpr size_type find_first_not_of( Ch const* s, size_type pos = 0 ) const noexcept;
+
+    // find_last_not_of
+
+    constexpr size_type find_last_not_of( basic_string_view str, size_type pos = npos ) const noexcept;
+    constexpr size_type find_last_not_of( Ch c, size_type pos = npos ) const noexcept;
+    constexpr size_type find_last_not_of( Ch const* s, size_type pos, size_type n ) const noexcept;
+    constexpr size_type find_last_not_of( Ch const* s, size_type pos = npos ) const noexcept;
+
+    // contains
+
+    constexpr bool contains( basic_string_view sv ) const noexcept;
+    constexpr bool contains( Ch c ) const noexcept;
+    constexpr bool contains( Ch const* s ) const noexcept;
+
+    // relational operators
+
+    constexpr friend bool operator==( basic_string_view sv1, basic_string_view sv2 ) noexcept;
+    constexpr friend bool operator!=( basic_string_view sv1, basic_string_view sv2 ) noexcept;
+    constexpr friend bool operator<( basic_string_view sv1, basic_string_view sv2 ) noexcept;
+    constexpr friend bool operator<=( basic_string_view sv1, basic_string_view sv2 ) noexcept;
+    constexpr friend bool operator>( basic_string_view sv1, basic_string_view sv2 ) noexcept;
+    constexpr friend bool operator>=( basic_string_view sv1, basic_string_view sv2 ) noexcept;
+};
+
+// stream inserter
+
+template<class Ch> std::basic_ostream<Ch>& operator<<( std::basic_ostream<Ch>& os, basic_string_view<Ch> str );
+
+// typedef names
+
+typedef basic_string_view<char> string_view;
+typedef basic_string_view<wchar_t> wstring_view;
+typedef basic_string_view<char16_t> u16string_view;
+typedef basic_string_view<char32_t> u32string_view;
+typedef basic_string_view<char8_t> u8string_view;
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section Construction]
+
+[section `constexpr basic_string_view() noexcept;`]
+
+* *Ensures:* `data() == 0`; `size() == 0`.
+
+[endsect]
+
+[section `constexpr basic_string_view( Ch const* str ) noexcept;`]
+
+* *Ensures:* `data() == str`; `size() == traits_type::length( str )`.
+
+[endsect]
+
+[section `constexpr basic_string_view( Ch const* str, size_type len ) noexcept;`]
+
+* *Ensures:* `data() == str`; `size() == len`.
+
+[endsect]
+
+[section `constexpr basic_string_view( Ch const* begin, Ch const* end ) noexcept;`]
+
+* *Requires:* `end >= begin`.
+* *Ensures:* `data() == begin`; `size() == end - begin`.
+
+[endsect]
+
+[section `template<class A> basic_string_view( std::basic_string<Ch, std::char_traits<Ch>, A> const& str ) noexcept;`]
+
+* *Ensures:* `data() == str.data()`; `size() == str.size()`.
+
+[endsect]
+
+[section `basic_string_view( std::basic_string_view<Ch, std::char_traits<Ch>> const& str ) noexcept;`]
+
+* *Ensures:* `data() == str.data()`; `size() == str.size()`.
+
+[endsect]
+
+[endsect]
+
+[section Conversions]
+
+[section `template<class A> operator std::basic_string<Ch, std::char_traits<Ch>, A>() const;`]
+
+* *Returns:* `std::basic_string<Ch, std::char_traits<Ch>, A>( data(), size() )`.
+
+[endsect]
+
+[section `template<class Ch2> operator std::basic_string_view<Ch2>() const noexcept;`]
+
+* *Constraints:* `Ch2` is the same type as `Ch`.
+* *Returns:* `std::basic_string_view<Ch2>( data(), size() )`.
+
+[endsect]
+
+[endsect]
+
+[section Iterator Support]
+
+[section `constexpr const_iterator begin() const noexcept;`]
+
+* *Returns:* `data()`.
+
+[endsect]
+
+[section `constexpr const_iterator end() const noexcept;`]
+
+* *Returns:* `data() + size()`.
+
+[endsect]
+
+[section `constexpr const_iterator cbegin() const noexcept;`]
+
+* *Returns:* `begin()`.
+
+[endsect]
+
+[section `constexpr const_iterator cend() const noexcept;`]
+
+* *Returns:* `end()`.
+
+[endsect]
+
+[section `constexpr const_reverse_iterator rbegin() const noexcept;`]
+
+* *Returns:* `const_reverse_iterator( end() )`.
+
+[endsect]
+
+[section `constexpr const_reverse_iterator rend() const noexcept;`]
+
+* *Returns:* `const_reverse_iterator( begin() )`.
+
+[endsect]
+
+[section `constexpr const_reverse_iterator crbegin() const noexcept;`]
+
+* *Returns:* `rbegin()`.
+
+[endsect]
+
+[section `constexpr const_reverse_iterator crend() const noexcept;`]
+
+* *Returns:* `rend()`.
+
+[endsect]
+
+[endsect]
+
+[section Capacity]
+
+[section `constexpr size_type size() const noexcept;`]
+
+* *Returns:* the length of the referenced character sequence.
+
+[endsect]
+
+[section `constexpr size_type length() const noexcept;`]
+
+* *Returns:* `size()`.
+
+[endsect]
+
+[section `constexpr size_type max_size() const noexcept;`]
+
+* *Returns:* `std::numeric_limits<size_type>::max() / sizeof(Ch)`.
+
+[endsect]
+
+[section `constexpr bool empty() const noexcept;`]
+
+* *Returns:* `size() == 0`.
+
+[endsect]
+
+[endsect]
+
+[section Element Access]
+
+[section `constexpr const_reference operator[]( size_type pos ) const noexcept;`]
+
+* *Requires:* `pos < size()`.
+* *Returns:* `data()[ pos ]`.
+
+[endsect]
+
+[section `constexpr const_reference at( size_type pos ) const;`]
+
+* *Returns:* `data()[ pos ]`.
+* *Throws:* `std::out_of_range` when `pos >= size()`.
+
+[endsect]
+
+[section `constexpr const_reference front() const noexcept;`]
+
+* *Requires:* `!empty()`.
+* *Returns:* `data()[ 0 ]`.
+
+[endsect]
+
+[section `constexpr const_reference back() const noexcept;`]
+
+* *Requires:* `!empty()`.
+* *Returns:* `data()[ size() - 1 ]`.
+
+[endsect]
+
+[section `constexpr const_pointer data() const noexcept;`]
+
+* *Returns:* a pointer to the beginning of the referenced character sequence.
+
+[endsect]
+
+[endsect]
+
+[section Modifiers]
+
+[section `constexpr void remove_prefix( size_type n ) noexcept;`]
+
+* *Requires:* `n <= size()`.
+* *Effects:* advances `data()` by `n` and decreases `size()` by `n`.
+
+[endsect]
+
+[section `constexpr void remove_suffix( size_type n ) noexcept;`]
+
+* *Requires:* `n <= size()`.
+* *Effects:* decreases `size()` by `n`.
+
+[endsect]
+
+[section `constexpr void swap( basic_string_view& s ) noexcept;`]
+
+* *Effects:* exchanges the contents of `*this` and `s`.
+
+[endsect]
+
+[endsect]
+
+[section String Operations]
+
+[section copy]
+
+[section `constexpr size_type copy( Ch* s, size_type n, size_type pos = 0 ) const;`]
+
+* *Effects:* copies to `s` the contents of `substr( pos, n )`.
+* *Throws:* `std::out_of_range` when `pos >= size()`.
+
+[endsect]
+
+[endsect]
+
+[section substr]
+
+[section `constexpr basic_string_view substr( size_type pos = 0, size_type n = npos ) const;`]
+
+* *Returns:* `basic_string_view( data() + pos, std::min( size() - pos, n ) )`.
+* *Throws:* `std::out_of_range` when `pos >= size()`.
+
+[endsect]
+
+[endsect]
+
+[section compare]
+
+[section `constexpr int compare( basic_string_view str ) const noexcept;`]
+
+* *Returns:*
+  * if `traits_type::compare( data(), str.data(), std::min( size(), str.size() ) )` is not zero, returns it. Otherwise,
+  * if `size() < str.size()`, returns a negative number. Otherwise,
+  * if `size() > str.size()`, returns a positive number. Otherwise,
+  * returns 0.
+
+[endsect]
+
+[section `constexpr int compare( size_type pos1, size_type n1, basic_string_view str ) const;`]
+
+* *Returns:* `substr( pos1, n1 ).compare( str )`.
+
+[endsect]
+
+[section `constexpr int compare( size_type pos1, size_type n1, basic_string_view str, size_type pos2, size_type n2 ) const;`]
+
+* *Returns:* `substr( pos1, n1 ).compare( str.substr( pos2, n2 ) )`.
+
+[endsect]
+
+[section `constexpr int compare( Ch const* s ) const noexcept;`]
+
+* *Returns:* `compare( basic_string_view( s ) )`.
+
+[endsect]
+
+[section `constexpr int compare( size_type pos1, size_type n1, Ch const* s ) const;`]
+
+* *Returns:* `substr( pos1, n1 ).compare( basic_string_view( s ) )`.
+
+[endsect]
+
+[section `constexpr int compare( size_type pos1, size_type n1, Ch const* s, size_type n2 ) const;`]
+
+* *Returns:* `substr( pos1, n1 ).compare( basic_string_view( s, n2 ) )`.
+
+[endsect]
+
+[endsect]
+
+[section starts_with]
+
+[section `constexpr bool starts_with( basic_string_view x ) const noexcept;`]
+
+* *Returns:* `substr( 0, x.size() ) == x`.
+
+[endsect]
+
+[section `constexpr bool starts_with( Ch x ) const noexcept;`]
+
+* *Returns:* `starts_with( basic_string_view( &x, 1 ) )`.
+
+[endsect]
+
+[section `constexpr bool starts_with( Ch const* x ) const noexcept;`]
+
+* *Returns:* `starts_with( basic_string_view( x ) )`.
+
+[endsect]
+
+[endsect]
+
+[section ends_with]
+
+[section `constexpr bool ends_with( basic_string_view x ) const noexcept;`]
+
+* *Returns:* `size() >= x.size() && substr( size() - x.size(), x.size() ) == x`.
+
+[endsect]
+
+[section `constexpr bool ends_with( Ch x ) const noexcept;`]
+
+* *Returns:* `ends_with( basic_string_view( &x, 1 ) )`.
+
+[endsect]
+
+[section `constexpr bool ends_with( Ch const* x ) const noexcept;`]
+
+* *Returns:* `ends_with( basic_string_view( x ) )`.
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Searching]
+
+[section find]
+
+[section `constexpr size_type find( basic_string_view str, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* The lowest position `i` such that `i >= pos` and `substr( i, str.size() ) == str`, or `npos` if such a position doesn't exist.
+
+[endsect]
+
+[section `constexpr size_type find( Ch c, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* `find( basic_string_view( &c, 1 ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find( Ch const* s, size_type pos, size_type n ) const noexcept;`]
+
+* *Returns:* `find( basic_string_view( s, n ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find( Ch const* s, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* `find( basic_string_view( s ), pos )`.
+
+[endsect]
+
+[endsect]
+
+[section rfind]
+
+[section `constexpr size_type rfind( basic_string_view str, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* The highest position `i` such that `i <= pos` and `substr( i, str.size() ) == str`, or `npos` if such a position doesn't exist.
+
+[endsect]
+
+[section `constexpr size_type rfind( Ch c, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* `rfind( basic_string_view( &c, 1 ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type rfind( Ch const* s, size_type pos, size_type n ) const noexcept;`]
+
+* *Returns:* `rfind( basic_string_view( s, n ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type rfind( Ch const* s, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* `rfind( basic_string_view( s ), pos )`.
+
+[endsect]
+
+[endsect]
+
+[section find_first_of]
+
+[section `constexpr size_type find_first_of( basic_string_view str, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* The lowest position `i` such that `i >= pos` and the character at position `i` is equal to one of the characters in `str`, or `npos` if such a position doesn't exist.
+
+[endsect]
+
+[section `constexpr size_type find_first_of( Ch c, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* `find_first_of( basic_string_view( &c, 1 ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_first_of( Ch const* s, size_type pos, size_type n ) const noexcept;`]
+
+* *Returns:* `find_first_of( basic_string_view( s, n ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_first_of( Ch const* s, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* `find_first_of( basic_string_view( s ), pos )`.
+
+[endsect]
+
+[endsect]
+
+[section find_last_of]
+
+[section `constexpr size_type find_last_of( basic_string_view str, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* The highest position `i` such that `i <= pos` and the character at position `i` is equal to one of the characters in `str`, or `npos` if such a position doesn't exist.
+
+[endsect]
+
+[section `constexpr size_type find_last_of( Ch c, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* `find_last_of( basic_string_view( &c, 1 ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_last_of( Ch const* s, size_type pos, size_type n ) const noexcept;`]
+
+* *Returns:* `find_last_of( basic_string_view( s, n ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_last_of( Ch const* s, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* `find_last_of( basic_string_view( s ), pos )`.
+
+[endsect]
+
+[endsect]
+
+[section find_first_not_of]
+
+[section `constexpr size_type find_first_not_of( basic_string_view str, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* The lowest position `i` such that `i >= pos` and the character at position `i` is not equal to one of the characters in `str`, or `npos` if such a position doesn't exist.
+
+[endsect]
+
+[section `constexpr size_type find_first_not_of( Ch c, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* `find_first_not_of( basic_string_view( &c, 1 ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_first_not_of( Ch const* s, size_type pos, size_type n ) const noexcept;`]
+
+* *Returns:* `find_first_not_of( basic_string_view( s, n ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_first_not_of( Ch const* s, size_type pos = 0 ) const noexcept;`]
+
+* *Returns:* `find_first_not_of( basic_string_view( s ), pos )`.
+
+[endsect]
+
+[endsect]
+
+[section find_last_not_of]
+
+[section `constexpr size_type find_last_not_of( basic_string_view str, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* The highest position `i` such that `i <= pos` and the character at position `i` is not equal to one of the characters in `str`, or `npos` if such a position doesn't exist.
+
+[endsect]
+
+[section `constexpr size_type find_last_not_of( Ch c, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* `find_last_not_of( basic_string_view( &c, 1 ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_last_not_of( Ch const* s, size_type pos, size_type n ) const noexcept;`]
+
+* *Returns:* `find_last_not_of( basic_string_view( s, n ), pos )`.
+
+[endsect]
+
+[section `constexpr size_type find_last_not_of( Ch const* s, size_type pos = npos ) const noexcept;`]
+
+* *Returns:* `find_last_not_of( basic_string_view( s ), pos )`.
+
+[endsect]
+
+[endsect]
+
+[section contains]
+
+[section `constexpr bool contains( basic_string_view sv ) const noexcept;`]
+
+* *Returns:* `find( sv ) != npos`.
+
+[endsect]
+
+[section `constexpr bool contains( Ch c ) const noexcept;`]
+
+* *Returns:* `find( c ) != npos`.
+
+[endsect]
+
+[section `constexpr bool contains( Ch const* s ) const noexcept;`]
+
+* *Returns:* `find( s ) != npos`.
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Relational Operators]
+
+[section `constexpr friend bool operator==( basic_string_view sv1, basic_string_view sv2 ) noexcept;`]
+
+* *Returns:* `sv1.compare( sv2 ) == 0`.
+
+[endsect]
+
+[section `constexpr friend bool operator!=( basic_string_view sv1, basic_string_view sv2 ) noexcept;`]
+
+* *Returns:* `sv1.compare( sv2 ) != 0`.
+
+[endsect]
+
+[section `constexpr friend bool operator<( basic_string_view sv1, basic_string_view sv2 ) noexcept;`]
+
+* *Returns:* `sv1.compare( sv2 ) < 0`.
+
+[endsect]
+
+[section `constexpr friend bool operator<=( basic_string_view sv1, basic_string_view sv2 ) noexcept;`]
+
+* *Returns:* `sv1.compare( sv2 ) <= 0`.
+
+[endsect]
+
+[section `constexpr friend bool operator>( basic_string_view sv1, basic_string_view sv2 ) noexcept;`]
+
+* *Returns:* `sv1.compare( sv2 ) > 0`.
+
+[endsect]
+
+[section `constexpr friend bool operator>=( basic_string_view sv1, basic_string_view sv2 ) noexcept;`]
+
+* *Returns:* `sv1.compare( sv2 ) >= 0`.
+
+[endsect]
+
+[endsect]
+
+[section Stream Inserter]
+
+[section `template<class Ch> std::basic_ostream<Ch>& operator<<( std::basic_ostream<Ch>& os, basic_string_view<Ch> str );`]
+
+* *Effects:* equivalent to `os << x`, where `x` is a pointer to a null-terminated character sequence with the same contents as `str`.
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/type_name.qbk

@@ -0,0 +1,77 @@
+[/
+  Copyright 2021 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:type_name type_name]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/type_name.hpp>]
+
+The header `<boost/core/type_name.hpp>` defines the function
+template `boost::core::type_name<T>()` that returns a string
+representation of the name of `T`, suitable for logging or
+diagnostic display purposes.
+
+The result is similar to `boost::core::demangle( typeid(T).name() )`,
+but it's made more regular by eliminating some of the platform-specific
+differences and extra template parameters of the standard library
+container types.
+
+For example, `type_name< std::map<std::string, int> >()` returns
+`"std::map<std::string, int>"` and not
+
+```
+  std::map<std::__cxx11::basic_string<char, std::char_traits<char>,
+    std::allocator<char> >, int, std::less<std::__cxx11::basic_string<char,
+    std::char_traits<char>, std::allocator<char> > >, std::allocator<
+    std::pair<std::__cxx11::basic_string<char, std::char_traits<char>,
+    std::allocator<char> > const, int> > >
+```
+
+or
+
+```
+  class std::map<class std::basic_string<char,struct std::char_traits<char>,
+    class std::allocator<char> >,int,struct std::less<class std::basic_string<
+    char,struct std::char_traits<char>,class std::allocator<char> > >,class
+    std::allocator<struct std::pair<class std::basic_string<char,struct
+    std::char_traits<char>,class std::allocator<char> > const ,int> > >
+```
+
+The return values aren't guaranteed to be stable across Boost releases.
+
+Compilation with `-fno-rtti` is supported, but the returned type names aren't
+guaranteed to be particularly useful or unique.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+template<class T> std::string type_name();
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section template<class T> std::string type_name();]
+
+* *Returns:* A string representation of the name of `T`.
+
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/allocator_access.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2020 Glen Joseph Fernandes
+Copyright 2020-2021 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -11,11 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
 #include <boost/core/pointer_traits.hpp>
-#if !defined(BOOST_MSVC)
 #include <limits>
-#else
-#include <memory>
-#endif
 #include <type_traits>
 #endif
 #include <new>
@@ -23,21 +19,18 @@ Distributed under the Boost Software License, Version 1.0.
 #include <utility>
 #endif
 
-namespace boost {
-namespace detail {
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-struct alloc_false {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-#else
-template<class>
-struct alloc_void {
-    typedef void type;
-};
+#if defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH)
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+#endif
+#if defined(_STL_DISABLE_DEPRECATED_WARNING)
+_STL_DISABLE_DEPRECATED_WARNING
+#endif
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996)
 #endif
 
-} /* detail */
+namespace boost {
 
 template<class A>
 struct allocator_value_type {
@@ -49,17 +42,21 @@ template<class A>
 struct allocator_pointer {
     typedef typename A::pointer type;
 };
-#elif defined(BOOST_MSVC)
-template<class A>
-struct allocator_pointer {
-    typedef typename std::allocator_traits<A>::pointer type;
-};
 #else
 template<class A, class = void>
 struct allocator_pointer {
     typedef typename A::value_type* type;
 };
 
+namespace detail {
+
+template<class>
+struct alloc_void {
+    typedef void type;
+};
+
+} /* detail */
+
 template<class A>
 struct allocator_pointer<A,
     typename detail::alloc_void<typename A::pointer>::type> {
@@ -72,11 +69,6 @@ template<class A>
 struct allocator_const_pointer {
     typedef typename A::const_pointer type;
 };
-#elif defined(BOOST_MSVC)
-template<class A>
-struct allocator_const_pointer {
-    typedef typename std::allocator_traits<A>::const_pointer type;
-};
 #else
 template<class A, class = void>
 struct allocator_const_pointer {
@@ -171,6 +163,14 @@ struct allocator_size_type<A,
 #endif
 
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
+namespace detail {
+
+struct alloc_false {
+    BOOST_STATIC_CONSTEXPR bool value = false;
+};
+
+} /* detail */
+
 template<class A>
 struct allocator_propagate_on_container_copy_assignment {
     typedef detail::alloc_false type;
@@ -250,11 +250,6 @@ template<class A, class T>
 struct allocator_rebind {
     typedef typename A::template rebind<T>::other type;
 };
-#elif defined(BOOST_MSVC)
-template<class A, class T>
-struct allocator_rebind {
-    typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
-};
 #else
 namespace detail {
 
@@ -303,36 +298,31 @@ allocator_allocate(A& a, typename allocator_size_type<A>::type n,
 {
     return a.allocate(n, h);
 }
-#elif defined(BOOST_MSVC)
-template<class A>
-inline typename allocator_pointer<A>::type
-allocator_allocate(A& a, typename allocator_size_type<A>::type n,
-    typename allocator_const_void_pointer<A>::type h)
-{
-    return std::allocator_traits<A>::allocate(a, n, h);
-}
 #else
 namespace detail {
 
-template<class, class, class, class = void>
-struct alloc_has_allocate {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
+struct alloc_none { };
 
-template<class A, class N, class H>
-struct alloc_has_allocate<A, N, H,
-    typename alloc_void<decltype(std::declval<A&>().allocate(std::declval<N>(),
-        std::declval<H>()))>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
+template<class A>
+class alloc_has_allocate {
+    template<class O>
+    static auto check(int) -> decltype(std::declval<O&>().allocate(
+        std::declval<typename allocator_size_type<A>::type>(),
+        std::declval<typename allocator_const_void_pointer<A>::type>()));
+
+    template<class>
+    static alloc_none check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value =
+        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
 };
 
 } /* detail */
 
 template<class A>
-inline typename std::enable_if<detail::alloc_has_allocate<A,
-    typename allocator_size_type<A>::type,
-        typename allocator_const_void_pointer<A>::type>::value,
-            typename allocator_pointer<A>::type>::type
+inline typename std::enable_if<detail::alloc_has_allocate<A>::value,
+    typename allocator_pointer<A>::type>::type
 allocator_allocate(A& a, typename allocator_size_type<A>::type n,
     typename allocator_const_void_pointer<A>::type h)
 {
@@ -340,10 +330,8 @@ allocator_allocate(A& a, typename allocator_size_type<A>::type n,
 }
 
 template<class A>
-inline typename std::enable_if<!detail::alloc_has_allocate<A,
-    typename allocator_size_type<A>::type,
-        typename allocator_const_void_pointer<A>::type>::value,
-            typename allocator_pointer<A>::type>::type
+inline typename std::enable_if<!detail::alloc_has_allocate<A>::value,
+    typename allocator_pointer<A>::type>::type
 allocator_allocate(A& a, typename allocator_size_type<A>::type n,
     typename allocator_const_void_pointer<A>::type)
 {
@@ -390,32 +378,28 @@ allocator_construct(A&, T* p, V& v)
     ::new((void*)p) T(v);
 }
 #endif
-#elif defined(BOOST_MSVC)
-template<class A, class T, class... Args>
-inline void
-allocator_construct(A& a, T* p, Args&&... args)
-{
-    std::allocator_traits<A>::construct(a, p, std::forward<Args>(args)...);
-}
 #else
 namespace detail {
 
-template<class, class, class, class...>
-struct alloc_has_construct {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
 template<class A, class T, class... Args>
-struct alloc_has_construct<typename alloc_void<decltype(std::declval<A
-    &>().construct(std::declval<T*>(), std::declval<Args&&>()...))>::type,
-        A, T, Args...> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
+class alloc_has_construct {
+    template<class O>
+    static auto check(int)
+    -> decltype(std::declval<O&>().construct(std::declval<T*>(),
+        std::declval<Args&&>()...));
+
+    template<class>
+    static alloc_none check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value =
+        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
 };
 
 } /* detail */
 
 template<class A, class T, class... Args>
-inline typename std::enable_if<detail::alloc_has_construct<void, A, T,
+inline typename std::enable_if<detail::alloc_has_construct<A, T,
     Args...>::value>::type
 allocator_construct(A& a, T* p, Args&&... args)
 {
@@ -423,7 +407,7 @@ allocator_construct(A& a, T* p, Args&&... args)
 }
 
 template<class A, class T, class... Args>
-inline typename std::enable_if<!detail::alloc_has_construct<void, A, T,
+inline typename std::enable_if<!detail::alloc_has_construct<A, T,
     Args...>::value>::type
 allocator_construct(A&, T* p, Args&&... args)
 {
@@ -439,26 +423,21 @@ allocator_destroy(A&, T* p)
     p->~T();
     (void)p;
 }
-#elif defined(BOOST_MSVC)
-template<class A, class T>
-inline void
-allocator_destroy(A& a, T* p)
-{
-    std::allocator_traits<A>::destroy(a, p);
-}
 #else
 namespace detail {
 
-template<class, class, class = void>
-struct alloc_has_destroy {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
 template<class A, class T>
-struct alloc_has_destroy<A, T,
-    typename alloc_void<decltype(std::declval<A
-        &>().destroy(std::declval<T*>()))>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
+class alloc_has_destroy {
+    template<class O>
+    static auto check(int)
+    -> decltype(std::declval<O&>().destroy(std::declval<T*>()));
+
+    template<class>
+    static alloc_none check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value =
+        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
 };
 
 } /* detail */
@@ -486,26 +465,20 @@ allocator_max_size(const A& a)
 {
     return a.max_size();
 }
-#elif defined(BOOST_MSVC)
-template<class A>
-inline typename allocator_size_type<A>::type
-allocator_max_size(const A& a)
-{
-    return std::allocator_traits<A>::max_size(a);
-}
 #else
 namespace detail {
 
-template<class, class = void>
-struct alloc_has_max_size {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
 template<class A>
-struct alloc_has_max_size<A,
-    typename alloc_void<decltype(std::declval<const
-        A&>().max_size())>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
+class alloc_has_max_size {
+    template<class O>
+    static auto check(int) -> decltype(std::declval<O&>().max_size());
+
+    template<class>
+    static alloc_none check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value =
+        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
 };
 
 } /* detail */
@@ -535,26 +508,21 @@ allocator_select_on_container_copy_construction(const A& a)
 {
     return a;
 }
-#elif defined(BOOST_MSVC)
-template<class A>
-inline A
-allocator_select_on_container_copy_construction(const A& a)
-{
-    return std::allocator_traits<A>::select_on_container_copy_construction(a);
-}
 #else
 namespace detail {
 
-template<class, class = void>
-struct alloc_has_soccc {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
 template<class A>
-struct alloc_has_soccc<A,
-    typename alloc_void<decltype(std::declval<const
-        A&>().select_on_container_copy_construction())>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
+class alloc_has_soccc {
+    template<class O>
+    static auto check(int)
+    -> decltype(std::declval<O&>().select_on_container_copy_construction());
+
+    template<class>
+    static alloc_none check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value =
+        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
 };
 
 } /* detail */
@@ -620,4 +588,14 @@ using allocator_rebind_t = typename allocator_rebind<A, T>::type;
 
 } /* boost */
 
+#if defined(_LIBCPP_SUPPRESS_DEPRECATED_POP)
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+#endif
+#if defined(_STL_RESTORE_DEPRECATED_WARNING)
+_STL_RESTORE_DEPRECATED_WARNING
+#endif
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
 #endif

include/boost/core/bit.hpp

@@ -0,0 +1,592 @@
+#ifndef BOOST_CORE_BIT_HPP_INCLUDED
+#define BOOST_CORE_BIT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/bit.hpp
+//
+// A portable version of the C++20 standard header <bit>
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+#include <cstring>
+
+#if defined(_MSC_VER)
+
+# include <intrin.h>
+# pragma intrinsic(_BitScanForward)
+# pragma intrinsic(_BitScanReverse)
+
+# if defined(_M_X64)
+#  pragma intrinsic(_BitScanForward64)
+#  pragma intrinsic(_BitScanReverse64)
+# endif
+
+# pragma warning(push)
+# pragma warning(disable: 4127) // conditional expression is constant
+# pragma warning(disable: 4244) // conversion from int to T
+
+#endif // defined(_MSC_VER)
+
+namespace boost
+{
+namespace core
+{
+
+// bit_cast
+
+template<class To, class From>
+To bit_cast( From const & from ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( sizeof(To) == sizeof(From) );
+
+    To to;
+    std::memcpy( &to, &from, sizeof(To) );
+    return to;
+}
+
+// countl
+
+#if defined(__GNUC__) || defined(__clang__)
+
+namespace detail
+{
+
+BOOST_CONSTEXPR inline int countl_impl( unsigned char x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_clz( x ) - ( std::numeric_limits<unsigned int>::digits - std::numeric_limits<unsigned char>::digits ): std::numeric_limits<unsigned char>::digits;
+}
+
+BOOST_CONSTEXPR inline int countl_impl( unsigned short x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_clz( x ) - ( std::numeric_limits<unsigned int>::digits - std::numeric_limits<unsigned short>::digits ): std::numeric_limits<unsigned short>::digits;
+}
+
+BOOST_CONSTEXPR inline int countl_impl( unsigned int x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_clz( x ): std::numeric_limits<unsigned int>::digits;
+}
+
+BOOST_CONSTEXPR inline int countl_impl( unsigned long x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_clzl( x ): std::numeric_limits<unsigned long>::digits;
+}
+
+BOOST_CONSTEXPR inline int countl_impl( unsigned long long x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_clzll( x ): std::numeric_limits<unsigned long long>::digits;
+}
+
+} // namespace detail
+
+template<class T>
+BOOST_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( x );
+}
+
+#else // defined(__GNUC__) || defined(__clang__)
+
+namespace detail
+{
+
+inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+#if defined(_MSC_VER)
+
+    unsigned long r;
+
+    if( _BitScanReverse( &r, x ) )
+    {
+        return 31 - static_cast<int>( r );
+    }
+    else
+    {
+        return 32;
+    }
+
+#else
+
+    static unsigned char const mod37[ 37 ] = { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7, 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
+
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+
+    return mod37[ x % 37 ];
+
+#endif
+}
+
+inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+#if defined(_MSC_VER) && defined(_M_X64)
+
+    unsigned long r;
+
+    if( _BitScanReverse64( &r, x ) )
+    {
+        return 63 - static_cast<int>( r );
+    }
+    else
+    {
+        return 64;
+    }
+
+#else
+
+    return static_cast<boost::uint32_t>( x >> 32 ) != 0?
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
+
+#endif
+}
+
+inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
+}
+
+inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+}
+
+} // namespace detail
+
+template<class T>
+int countl_zero( T x ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+
+    if( sizeof(T) == sizeof(boost::uint8_t) )
+    {
+        return boost::core::detail::countl_impl( static_cast<boost::uint8_t>( x ) );
+    }
+    else if( sizeof(T) == sizeof(boost::uint16_t) )
+    {
+        return boost::core::detail::countl_impl( static_cast<boost::uint16_t>( x ) );
+    }
+    else if( sizeof(T) == sizeof(boost::uint32_t) )
+    {
+        return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) );
+    }
+    else
+    {
+        return boost::core::detail::countl_impl( static_cast<boost::uint64_t>( x ) );
+    }
+}
+
+#endif // defined(__GNUC__) || defined(__clang__)
+
+template<class T>
+BOOST_CONSTEXPR int countl_one( T x ) BOOST_NOEXCEPT
+{
+    return boost::core::countl_zero( static_cast<T>( ~x ) );
+}
+
+// countr
+
+#if defined(__GNUC__) || defined(__clang__)
+
+namespace detail
+{
+
+BOOST_CONSTEXPR inline int countr_impl( unsigned char x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_ctz( x ): std::numeric_limits<unsigned char>::digits;
+}
+
+BOOST_CONSTEXPR inline int countr_impl( unsigned short x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_ctz( x ): std::numeric_limits<unsigned short>::digits;
+}
+
+BOOST_CONSTEXPR inline int countr_impl( unsigned int x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_ctz( x ): std::numeric_limits<unsigned int>::digits;
+}
+
+BOOST_CONSTEXPR inline int countr_impl( unsigned long x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_ctzl( x ): std::numeric_limits<unsigned long>::digits;
+}
+
+BOOST_CONSTEXPR inline int countr_impl( unsigned long long x ) BOOST_NOEXCEPT
+{
+    return x? __builtin_ctzll( x ): std::numeric_limits<unsigned long long>::digits;
+}
+
+} // namespace detail
+
+template<class T>
+BOOST_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( x );
+}
+
+#else // defined(__GNUC__) || defined(__clang__)
+
+namespace detail
+{
+
+inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+#if defined(_MSC_VER)
+
+    unsigned long r;
+
+    if( _BitScanForward( &r, x ) )
+    {
+        return static_cast<int>( r );
+    }
+    else
+    {
+        return 32;
+    }
+
+#else
+
+    static unsigned char const mod37[ 37 ] = { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
+    return mod37[ ( -(boost::int32_t)x & x ) % 37 ];
+
+#endif
+}
+
+inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+#if defined(_MSC_VER) && defined(_M_X64)
+
+    unsigned long r;
+
+    if( _BitScanForward64( &r, x ) )
+    {
+        return static_cast<int>( r );
+    }
+    else
+    {
+        return 64;
+    }
+
+#else
+
+    return static_cast<boost::uint32_t>( x ) != 0?
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
+
+#endif
+}
+
+inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
+}
+
+inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+}
+
+} // namespace detail
+
+template<class T>
+int countr_zero( T x ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+
+    if( sizeof(T) == sizeof(boost::uint8_t) )
+    {
+        return boost::core::detail::countr_impl( static_cast<boost::uint8_t>( x ) );
+    }
+    else if( sizeof(T) == sizeof(boost::uint16_t) )
+    {
+        return boost::core::detail::countr_impl( static_cast<boost::uint16_t>( x ) );
+    }
+    else if( sizeof(T) == sizeof(boost::uint32_t) )
+    {
+        return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) );
+    }
+    else
+    {
+        return boost::core::detail::countr_impl( static_cast<boost::uint64_t>( x ) );
+    }
+}
+
+#endif // defined(__GNUC__) || defined(__clang__)
+
+template<class T>
+BOOST_CONSTEXPR int countr_one( T x ) BOOST_NOEXCEPT
+{
+    return boost::core::countr_zero( static_cast<T>( ~x ) );
+}
+
+// popcount
+
+#if defined(__GNUC__) || defined(__clang__)
+
+#if defined(__clang__) && __clang_major__ * 100 + __clang_minor__ < 304
+# define BOOST_CORE_POPCOUNT_CONSTEXPR
+#else
+# define BOOST_CORE_POPCOUNT_CONSTEXPR BOOST_CONSTEXPR
+#endif
+
+namespace detail
+{
+
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned char x ) BOOST_NOEXCEPT
+{
+    return __builtin_popcount( x );
+}
+
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned short x ) BOOST_NOEXCEPT
+{
+    return __builtin_popcount( x );
+}
+
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned int x ) BOOST_NOEXCEPT
+{
+    return __builtin_popcount( x );
+}
+
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long x ) BOOST_NOEXCEPT
+{
+    return __builtin_popcountl( x );
+}
+
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long long x ) BOOST_NOEXCEPT
+{
+    return __builtin_popcountll( x );
+}
+
+} // namespace detail
+
+#undef BOOST_CORE_POPCOUNT_CONSTEXPR
+
+template<class T>
+BOOST_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::popcount_impl( x );
+}
+
+#else // defined(__GNUC__) || defined(__clang__)
+
+namespace detail
+{
+
+BOOST_CXX14_CONSTEXPR inline int popcount_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    x = x - ( ( x >> 1 ) & 0x55555555 );
+    x = ( x & 0x33333333 ) + ( ( x >> 2 ) & 0x33333333 );
+    x = ( x + ( x >> 4 ) ) & 0x0F0F0F0F;
+
+    return static_cast<unsigned>( ( x * 0x01010101 ) >> 24 );
+}
+
+BOOST_CXX14_CONSTEXPR inline int popcount_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    x = x - ( ( x >> 1 ) & 0x5555555555555555 );
+    x = ( x & 0x3333333333333333 ) + ( ( x >> 2 ) & 0x3333333333333333 );
+    x = ( x + ( x >> 4 ) ) & 0x0F0F0F0F0F0F0F0F;
+
+    return static_cast<unsigned>( ( x * 0x0101010101010101 ) >> 56 );
+}
+
+} // namespace detail
+
+template<class T>
+BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
+
+    if( sizeof(T) <= sizeof(boost::uint32_t) )
+    {
+        return boost::core::detail::popcount_impl( static_cast<boost::uint32_t>( x ) );
+    }
+    else
+    {
+        return boost::core::detail::popcount_impl( static_cast<boost::uint64_t>( x ) );
+    }
+}
+
+#endif // defined(__GNUC__) || defined(__clang__)
+
+// rotating
+
+template<class T>
+BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
+{
+    unsigned const mask = std::numeric_limits<T>::digits - 1;
+    return x << (s & mask) | x >> ((-s) & mask);
+}
+
+template<class T>
+BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
+{
+    unsigned const mask = std::numeric_limits<T>::digits - 1;
+    return x >> (s & mask) | x << ((-s) & mask);
+}
+
+// integral powers of 2
+
+template<class T>
+BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
+{
+    return x != 0 && ( x & ( x - 1 ) ) == 0;
+}
+
+template<class T>
+BOOST_CONSTEXPR T bit_width( T x ) BOOST_NOEXCEPT
+{
+    return std::numeric_limits<T>::digits - boost::core::countl_zero( x );
+}
+
+template<class T>
+BOOST_CONSTEXPR T bit_floor( T x ) BOOST_NOEXCEPT
+{
+    return x == 0? 0: T(1) << ( boost::core::bit_width( x ) - 1 );
+}
+
+namespace detail
+{
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t bit_ceil_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    if( x == 0 )
+    {
+        return 0;
+    }
+
+    --x;
+
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+
+    ++x;
+
+    return x;
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t bit_ceil_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( x == 0 )
+    {
+        return 0;
+    }
+
+    --x;
+
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    x |= x >> 32;
+
+    ++x;
+
+    return x;
+}
+
+} // namespace detail
+
+template<class T>
+BOOST_CXX14_CONSTEXPR T bit_ceil( T x ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
+
+    if( sizeof(T) <= sizeof(boost::uint32_t) )
+    {
+        return static_cast<T>( boost::core::detail::bit_ceil_impl( static_cast<boost::uint32_t>( x ) ) );
+    }
+    else
+    {
+        return static_cast<T>( boost::core::detail::bit_ceil_impl( static_cast<boost::uint64_t>( x ) ) );
+    }
+}
+
+// endian
+
+#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER =little
+
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER =big
+
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_PDP_ENDIAN__) && __BYTE_ORDER__ == __ORDER_PDP_ENDIAN__
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER
+
+#elif defined(__LITTLE_ENDIAN__)
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER =little
+
+#elif defined(__BIG_ENDIAN__)
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER =big
+
+#elif defined(_MSC_VER) || defined(__i386__) || defined(__x86_64__)
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER =little
+
+#else
+
+# define BOOST_CORE_BIT_NATIVE_INITIALIZER
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
+enum class endian
+{
+    big,
+    little,
+    native BOOST_CORE_BIT_NATIVE_INITIALIZER
+};
+
+typedef endian endian_type;
+
+#else
+
+namespace endian
+{
+
+enum type
+{
+    big,
+    little,
+    native BOOST_CORE_BIT_NATIVE_INITIALIZER
+};
+
+} // namespace endian
+
+typedef endian::type endian_type;
+
+#endif
+
+#undef BOOST_CORE_BIT_NATIVE_INITIALIZER
+
+} // namespace core
+} // namespace boost
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif  // #ifndef BOOST_CORE_BIT_HPP_INCLUDED

include/boost/core/cmath.hpp

@@ -0,0 +1,298 @@
+#ifndef BOOST_CORE_CMATH_HPP_INCLUDED
+#define BOOST_CORE_CMATH_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/cmath.hpp
+//
+// Floating point classification and sign manipulation functions
+// Extracted from https://github.com/boostorg/lexical_cast/pull/37
+//
+// Copyright 2020, 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <cmath>
+
+#if defined(BOOST_CORE_USE_GENERIC_CMATH) || (!defined(_MSC_VER) && !defined(FP_SUBNORMAL))
+
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <limits>
+#include <cstring>
+
+namespace boost
+{
+namespace core
+{
+
+// fpclassify return values
+
+int const fp_zero = 0;
+int const fp_subnormal = 1;
+int const fp_normal = 2;
+int const fp_infinite = 3;
+int const fp_nan = 4;
+
+// Classification functions
+
+template<class T> bool isfinite( T x )
+{
+    return x <= (std::numeric_limits<T>::max)() && x >= -(std::numeric_limits<T>::max)();
+}
+
+template<class T> bool isinf( T x )
+{
+    return x > (std::numeric_limits<T>::max)() || x < -(std::numeric_limits<T>::max)();
+}
+
+template<class T> bool isnan( T x )
+{
+    return !isfinite( x ) && !isinf( x );
+}
+
+template<class T> bool isnormal( T x )
+{
+    return isfinite( x ) && ( x >= (std::numeric_limits<T>::min)() || x <= -(std::numeric_limits<T>::min)() );
+}
+
+template<class T> int fpclassify( T x )
+{
+    if( x == 0 ) return fp_zero;
+
+    if( x < 0 ) x = -x;
+
+    if( x > (std::numeric_limits<T>::max)() ) return fp_infinite;
+
+    if( x >= (std::numeric_limits<T>::min)() ) return fp_normal;
+
+    if( x < (std::numeric_limits<T>::min)() ) return fp_subnormal;
+
+    return fp_nan;
+}
+
+// Sign manipulation functions
+
+inline bool signbit( float x )
+{
+    boost::int32_t y;
+
+    BOOST_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
+
+    std::memcpy( &y, &x, sizeof( y ) );
+
+    return y < 0;
+}
+
+inline bool signbit( double x )
+{
+    boost::int64_t y;
+
+    BOOST_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
+
+    std::memcpy( &y, &x, sizeof( y ) );
+
+    return y < 0;
+}
+
+inline bool signbit( long double x )
+{
+    return signbit( static_cast<double>( x ) );
+}
+
+template<class T> T copysign( T x, T y )
+{
+    return signbit( x ) == signbit( y )? x: -x;
+}
+
+} // namespace core
+} // namespace boost
+
+#else // defined(BOOST_CORE_USE_GENERIC_CMATH)
+
+#if defined(_MSC_VER) && _MSC_VER < 1800
+# include <float.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+#if defined(_MSC_VER) && _MSC_VER < 1800
+
+template<class T> T copysign( T x, T y )
+{
+    return static_cast<T>( _copysign( static_cast<double>( x ), static_cast<double>( y ) ) );
+}
+
+template<class T> bool isnan( T x )
+{
+    return _isnan( static_cast<double>( x ) ) != 0;
+}
+
+template<class T> bool isfinite( T x )
+{
+    return _finite( static_cast<double>( x ) ) != 0;
+}
+
+template<class T> bool isinf( T x )
+{
+    return ( _fpclass( static_cast<double>( x ) ) & ( _FPCLASS_PINF | _FPCLASS_NINF ) ) != 0;
+}
+
+inline bool isnormal( float x )
+{
+    // no _fpclassf in 32 bit mode
+    unsigned y = reinterpret_cast< unsigned const& >( x );
+    unsigned exp = ( y >> 23 ) & 0xFF;
+    return exp != 0 && exp != 0xFF;
+}
+
+inline bool isnormal( double x )
+{
+    return ( _fpclass( x ) & ( _FPCLASS_PN | _FPCLASS_NN ) ) != 0;
+}
+
+inline bool isnormal( long double x )
+{
+    return boost::core::isnormal( static_cast<double>( x ) );
+}
+
+template<class T> bool signbit( T x )
+{
+    return _copysign( 1.0, static_cast<double>( x ) ) < 0.0;
+}
+
+int const fp_zero = 0;
+int const fp_subnormal = 1;
+int const fp_normal = 2;
+int const fp_infinite = 3;
+int const fp_nan = 4;
+
+inline int fpclassify( float x )
+{
+    switch( _fpclass( x ) )
+    {
+    case _FPCLASS_SNAN:
+    case _FPCLASS_QNAN:
+
+        return fp_nan;
+
+    case _FPCLASS_NINF:
+    case _FPCLASS_PINF:
+
+        return fp_infinite;
+
+    case _FPCLASS_NZ:
+    case _FPCLASS_PZ:
+
+        return fp_zero;
+
+    default:
+
+        return boost::core::isnormal( x )? fp_normal: fp_subnormal;
+    }
+}
+
+inline int fpclassify( double x )
+{
+    switch( _fpclass( x ) )
+    {
+    case _FPCLASS_SNAN:
+    case _FPCLASS_QNAN:
+
+        return fp_nan;
+
+    case _FPCLASS_NINF:
+    case _FPCLASS_PINF:
+
+        return fp_infinite;
+
+    case _FPCLASS_NZ:
+    case _FPCLASS_PZ:
+
+        return fp_zero;
+
+    case _FPCLASS_ND:
+    case _FPCLASS_PD:
+
+        return fp_subnormal;
+
+    default:
+
+        return fp_normal;
+    }
+}
+
+inline int fpclassify( long double x )
+{
+    return boost::core::fpclassify( static_cast<double>( x ) );
+}
+
+#else
+
+using std::isfinite;
+using std::isnan;
+using std::isinf;
+using std::isnormal;
+using std::fpclassify;
+
+int const fp_zero = FP_ZERO;
+int const fp_subnormal = FP_SUBNORMAL;
+int const fp_normal = FP_NORMAL;
+int const fp_infinite = FP_INFINITE;
+int const fp_nan = FP_NAN;
+
+using std::signbit;
+
+// std::copysign doesn't exist in libstdc++ under -std=c++03
+
+#if !defined(__GNUC__)
+
+template<class T> T copysign( T x, T y )
+{
+    return std::copysign( x, y );
+}
+
+#else
+
+namespace detail
+{
+
+// ::copysignl is unreliable, use the built-ins
+
+inline float copysign_impl( float x, float y )
+{
+    return __builtin_copysignf( x, y );
+}
+
+inline double copysign_impl( double x, double y )
+{
+    return __builtin_copysign( x, y );
+}
+
+inline long double copysign_impl( long double x, long double y )
+{
+    return __builtin_copysignl( x, y );
+}
+
+} // namespace detail
+
+template<class T> T copysign( T x, T y )
+{
+    return boost::core::detail::copysign_impl( x, y );
+}
+
+#endif // !defined(__GNUC__)
+#endif // #if defined(_MSC_VER) && _MSC_VER < 1800
+
+} // namespace core
+} // namespace boost
+
+#endif // defined(BOOST_CORE_USE_GENERIC_CMATH)
+
+#endif  // #ifndef BOOST_CORE_CMATH_HPP_INCLUDED

include/boost/core/detail/splitmix64.hpp

@@ -0,0 +1,54 @@
+#ifndef BOOST_CORE_DETAIL_SPLITMIX64_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SPLITMIX64_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+//
+// An implementation of splitmix64 for testing purposes,
+// derived from Sebastiano Vigna's public domain implementation
+// http://xorshift.di.unimi.it/splitmix64.c
+
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+namespace detail
+{
+
+class splitmix64
+{
+private:
+
+    boost::uint64_t x_;
+
+public:
+
+    splitmix64(): x_( 0 )
+    {
+    }
+
+    explicit splitmix64( boost::uint64_t seed ): x_( seed )
+    {
+    }
+
+    boost::uint64_t operator()()
+    {
+        x_ += 0x9e3779b97f4a7c15;
+
+        boost::uint64_t z = x_;
+
+        z ^= z >> 30;
+        z *= 0xbf58476d1ce4e5b9;
+        z ^= z >> 27;
+        z *= 0x94d049bb133111eb;
+        z ^= z >> 31;
+
+        return z;
+    }
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_SPLITMIX64_HPP_INCLUDED

include/boost/core/empty_value.hpp

@@ -25,6 +25,11 @@ Distributed under the Boost Software License, Version 1.0.
 #endif
 #endif
 
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4510)
+#endif
+
 namespace boost {
 
 template<class T>
@@ -143,4 +148,8 @@ BOOST_INLINE_CONSTEXPR empty_init_t empty_init = empty_init_t();
 
 } /* boost */
 
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
 #endif

include/boost/core/ignore_unused.hpp

@@ -11,34 +11,64 @@
 
 namespace boost {
 
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+template <typename... Ts>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(Ts&& ...)
+{}
+
+#else
 
 template <typename... Ts>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(Ts const& ...)
 {}
 
+#endif
+
 template <typename... Ts>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
 {}
 
-#else
+#else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename T1>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1&)
+{}
 
 template <typename T1>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&)
 {}
 
+template <typename T1, typename T2>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1&, T2&)
+{}
+
 template <typename T1, typename T2>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&)
 {}
 
+template <typename T1, typename T2, typename T3>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1&, T2&, T3&)
+{}
+
 template <typename T1, typename T2, typename T3>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&)
 {}
 
+template <typename T1, typename T2, typename T3, typename T4>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1&, T2&, T3&, T4&)
+{}
+
 template <typename T1, typename T2, typename T3, typename T4>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&)
 {}
 
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1&, T2&, T3&, T4&, T5&)
+{}
+
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
 BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&, T5 const&)
 {}

include/boost/core/lightweight_test.hpp

@@ -27,9 +27,12 @@
 #include <exception>
 #include <iostream>
 #include <iterator>
+#include <string>
 #include <cstdlib>
 #include <cstring>
 #include <cstddef>
+#include <cctype>
+#include <cstdio>
 
 #if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
 # include <crtdbg.h>
@@ -173,6 +176,51 @@ template<class T> inline const void* test_output_impl(T volatile* v) { return co
 inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
 #endif
 
+// print chars as numeric
+
+inline int test_output_impl( signed char const& v ) { return v; }
+inline unsigned test_output_impl( unsigned char const& v ) { return v; }
+
+// Whether wchar_t is signed is implementation-defined
+
+template<bool Signed> struct lwt_long_type {};
+template<> struct lwt_long_type<true> { typedef long type; };
+template<> struct lwt_long_type<false> { typedef unsigned long type; };
+
+inline lwt_long_type<(static_cast<wchar_t>(-1) < static_cast<wchar_t>(0))>::type test_output_impl( wchar_t const& v ) { return v; }
+
+#if !defined( BOOST_NO_CXX11_CHAR16_T )
+inline unsigned long test_output_impl( char16_t const& v ) { return v; }
+#endif
+
+#if !defined( BOOST_NO_CXX11_CHAR32_T )
+inline unsigned long test_output_impl( char32_t const& v ) { return v; }
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif
+
+inline std::string test_output_impl( char const& v )
+{
+    if( std::isprint( static_cast<unsigned char>( v ) ) )
+    {
+        return std::string( 1, v );
+    }
+    else
+    {
+        char buffer[ 8 ];
+        std::sprintf( buffer, "\\x%02X", static_cast<unsigned char>( v ) );
+
+        return buffer;
+    }
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
 // predicates
 
 struct lw_test_eq

include/boost/core/lightweight_test_trait.hpp

@@ -11,7 +11,7 @@
 //
 // BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE, BOOST_TEST_TRAIT_SAME
 //
-// Copyright 2014 Peter Dimov
+// Copyright 2014, 2021 Peter Dimov
 //
 // Copyright 2019 Glen Joseph Fernandes
 // (glenjofe@gmail.com)
@@ -21,60 +21,15 @@
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/core/lightweight_test.hpp>
-#include <boost/core/typeinfo.hpp>
+#include <boost/core/type_name.hpp>
 #include <boost/core/is_same.hpp>
 #include <boost/config.hpp>
 
 namespace boost
 {
-
 namespace detail
 {
 
-template<class, int = 0> struct test_print { };
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 2>)
-{
-    return o << boost::core::demangled_name(BOOST_CORE_TYPEID(T));
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 1>)
-{
-    return o << test_print<T, 2>();
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const T, 1>)
-{
-    return o << test_print<T, 2>() << " const";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<volatile T, 1>)
-{
-    return o << test_print<T, 2>() << " volatile";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const volatile T, 1>)
-{
-    return o << test_print<T, 2>() << " const volatile";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T>)
-{
-    return o << test_print<T, 1>();
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&>)
-{
-    return o << test_print<T, 1>() << " &";
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&&>)
-{
-    return o << test_print<T, 1>() << " &&";
-}
-#endif
-
 template< class T > inline void test_trait_impl( char const * trait, void (*)( T ),
   bool expected, char const * file, int line, char const * function )
 {
@@ -86,7 +41,7 @@ template< class T > inline void test_trait_impl( char const * trait, void (*)( T
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
             << file << "(" << line << "): predicate '" << trait << "' ["
-            << boost::core::demangled_name( BOOST_CORE_TYPEID(T) ) << "]"
+            << boost::core::type_name<T>() << "]"
             << " test failed in function '" << function
             << "' (should have been " << ( expected? "true": "false" ) << ")"
             << std::endl;
@@ -112,8 +67,8 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
             << file << "(" << line << "): test 'is_same<" << types << ">'"
             << " failed in function '" << function
-            << "' ('" << test_print<T1>()
-            << "' != '" << test_print<T2>() << "')"
+            << "' ('" << boost::core::type_name<T1>()
+            << "' != '" << boost::core::type_name<T2>() << "')"
             << std::endl;
 
         ++test_results().errors();
@@ -121,7 +76,6 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
 }
 
 } // namespace detail
-
 } // namespace boost
 
 #define BOOST_TEST_TRAIT_TRUE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, true, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )

include/boost/core/noinit_adaptor.hpp

@@ -56,6 +56,7 @@ struct noinit_adaptor
     template<class U>
     void destroy(U* p) {
         p->~U();
+        (void)p;
     }
 };
 

include/boost/core/ref.hpp

@@ -10,6 +10,7 @@
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/addressof.hpp>
+#include <boost/core/enable_if.hpp>
 
 //
 //  ref.hpp - ref/cref, useful helper functions
@@ -46,6 +47,26 @@ namespace boost
 
 #endif
 
+namespace detail
+{
+
+template< class Y, class T > struct ref_convertible
+{
+    typedef char (&yes) [1];
+    typedef char (&no)  [2];
+
+    static yes f( T* );
+    static no  f( ... );
+
+    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
+};
+
+struct ref_empty
+{
+};
+
+} // namespace detail
+
 // reference_wrapper
 
 /**
@@ -87,6 +108,21 @@ public:
 public:
 #endif
 
+    template<class Y> friend class reference_wrapper;
+
+    /**
+     Constructs a `reference_wrapper` object that stores the
+     reference stored in the compatible `reference_wrapper` `r`.
+
+     @remark Only enabled when `Y*` is convertible to `T*`.
+     @remark Does not throw.
+    */
+    template<class Y> reference_wrapper( reference_wrapper<Y> r,
+        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
+            boost::detail::ref_empty>::type = boost::detail::ref_empty() ): t_( r.t_ )
+    {
+    }
+
     /**
      @return The stored reference.
      @remark Does not throw.

include/boost/core/span.hpp

@@ -0,0 +1,407 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_SPAN_HPP
+#define BOOST_CORE_SPAN_HPP
+
+#include <array>
+#include <iterator>
+#include <type_traits>
+#include <cstddef>
+
+namespace boost {
+
+constexpr std::size_t dynamic_extent = static_cast<std::size_t>(-1);
+
+template<class T, std::size_t E = dynamic_extent>
+class span;
+
+namespace detail {
+
+template<class U, class T>
+struct span_convertible {
+    static constexpr bool value = std::is_convertible<U(*)[], T(*)[]>::value;
+};
+
+template<std::size_t E, std::size_t N>
+struct span_capacity {
+    static constexpr bool value = E == boost::dynamic_extent || E == N;
+};
+
+template<class T, std::size_t E, class U, std::size_t N>
+struct span_compatible {
+    static constexpr bool value = span_capacity<E, N>::value &&
+        span_convertible<U, T>::value;
+};
+
+template<class T>
+struct span_uncvref {
+    typedef typename std::remove_cv<typename
+        std::remove_reference<T>::type>::type type;
+};
+
+template<class>
+struct span_is_span {
+    static constexpr bool value = false;
+};
+
+template<class T, std::size_t E>
+struct span_is_span<boost::span<T, E> > {
+    static constexpr bool value = true;
+};
+
+template<class T>
+struct span_is_array {
+    static constexpr bool value = false;
+};
+
+template<class T, std::size_t N>
+struct span_is_array<std::array<T, N> > {
+    static constexpr bool value = true;
+};
+
+template<class, class = void>
+struct span_data { };
+
+template<class T>
+struct span_data<T,
+    typename std::enable_if<std::is_pointer<decltype(std::declval<T
+        &>().data())>::value>::type> {
+    typedef typename std::remove_pointer<decltype(std::declval<T
+        &>().data())>::type type;
+};
+
+template<class, class, class = void>
+struct span_has_data {
+    static constexpr bool value = false;
+};
+
+template<class R, class T>
+struct span_has_data<R, T, typename std::enable_if<span_convertible<typename
+    span_data<R>::type, T>::value>::type> {
+    static constexpr bool value = true;
+};
+
+template<class, class = void>
+struct span_has_size {
+    static constexpr bool value = false;
+};
+
+template<class R>
+struct span_has_size<R, typename
+    std::enable_if<std::is_convertible<decltype(std::declval<R&>().size()),
+        std::size_t>::value>::type> {
+    static constexpr bool value = true;
+};
+
+template<class R, class T>
+struct span_is_range {
+    static constexpr bool value = (std::is_const<T>::value ||
+        std::is_lvalue_reference<R>::value) &&
+        !span_is_span<typename span_uncvref<R>::type>::value &&
+        !span_is_array<typename span_uncvref<R>::type>::value &&
+        !std::is_array<typename span_uncvref<R>::type>::value &&
+        span_has_data<R, T>::value &&
+        span_has_size<R>::value;
+};
+
+template<std::size_t E, std::size_t N>
+struct span_implicit {
+    static constexpr bool value = E == boost::dynamic_extent ||
+        N != boost::dynamic_extent;
+};
+
+template<class T, std::size_t E, class U, std::size_t N>
+struct span_copyable {
+    static constexpr bool value = (N == boost::dynamic_extent ||
+        span_capacity<E, N>::value) && span_convertible<U, T>::value;
+};
+
+template<std::size_t E, std::size_t O>
+struct span_sub {
+    static constexpr std::size_t value = E == boost::dynamic_extent ?
+        boost::dynamic_extent : E - O;
+};
+
+template<class T, std::size_t E>
+struct span_store {
+    constexpr span_store(T* p_, std::size_t) noexcept
+        : p(p_) { }
+    static constexpr std::size_t n = E;
+    T* p;
+};
+
+template<class T>
+struct span_store<T, boost::dynamic_extent> {
+    constexpr span_store(T* p_, std::size_t n_) noexcept
+        : p(p_)
+        , n(n_) { }
+    T* p;
+    std::size_t n;
+};
+
+template<class T, std::size_t E>
+struct span_bytes {
+    static constexpr std::size_t value = sizeof(T) * E;
+};
+
+template<class T>
+struct span_bytes<T, boost::dynamic_extent> {
+    static constexpr std::size_t value = boost::dynamic_extent;
+};
+
+} /* detail */
+
+template<class T, std::size_t E>
+class span {
+public:
+    typedef T element_type;
+    typedef typename std::remove_cv<T>::type value_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    typedef std::reverse_iterator<T*> reverse_iterator;
+    typedef std::reverse_iterator<const T*> const_reverse_iterator;
+
+    static constexpr std::size_t extent = E;
+
+    template<std::size_t N = E,
+        typename std::enable_if<N == dynamic_extent || N == 0, int>::type = 0>
+    constexpr span() noexcept
+        : s_(0, 0) { }
+
+    template<class I,
+        typename std::enable_if<E == dynamic_extent &&
+            detail::span_convertible<I, T>::value, int>::type = 0>
+    constexpr span(I* f, size_type c)
+        : s_(f, c) { }
+
+    template<class I,
+        typename std::enable_if<E != dynamic_extent &&
+            detail::span_convertible<I, T>::value, int>::type = 0>
+    explicit constexpr span(I* f, size_type c)
+        : s_(f, c) { }
+
+    template<class I, class L,
+        typename std::enable_if<E == dynamic_extent &&
+            detail::span_convertible<I, T>::value, int>::type = 0>
+    constexpr span(I* f, L* l)
+        : s_(f, l - f) { }
+
+    template<class I, class L,
+        typename std::enable_if<E != dynamic_extent &&
+            detail::span_convertible<I, T>::value, int>::type = 0>
+    explicit constexpr span(I* f, L* l)
+        : s_(f, l - f) { }
+
+    template<std::size_t N,
+        typename std::enable_if<detail::span_capacity<E, N>::value,
+            int>::type = 0>
+    constexpr span(typename std::enable_if<true, T>::type (&a)[N]) noexcept
+        : s_(a, N) { }
+
+    template<class U, std::size_t N,
+        typename std::enable_if<detail::span_compatible<T, E, U, N>::value,
+            int>::type = 0>
+    constexpr span(std::array<U, N>& a) noexcept
+        : s_(a.data(), N) { }
+
+    template<class U, std::size_t N,
+        typename std::enable_if<detail::span_compatible<T, E, const U,
+            N>::value, int>::type = 0>
+    constexpr span(const std::array<U, N>& a) noexcept
+        : s_(a.data(), N) { }
+
+    template<class R,
+        typename std::enable_if<E == dynamic_extent &&
+            detail::span_is_range<R, T>::value, int>::type = 0>
+    constexpr span(R&& r) noexcept(noexcept(r.data()) && noexcept(r.size()))
+        : s_(r.data(), r.size()) { }
+
+    template<class R,
+        typename std::enable_if<E != dynamic_extent &&
+            detail::span_is_range<R, T>::value, int>::type = 0>
+    explicit constexpr span(R&& r) noexcept(noexcept(r.data()) &&
+        noexcept(r.size()))
+        : s_(r.data(), r.size()) { }
+
+    template<class U, std::size_t N,
+        typename std::enable_if<detail::span_implicit<E, N>::value &&
+            detail::span_copyable<T, E, U, N>::value, int>::type = 0>
+    constexpr span(const span<U, N>& s) noexcept
+        : s_(s.data(), s.size()) { }
+
+    template<class U, std::size_t N,
+        typename std::enable_if<!detail::span_implicit<E, N>::value &&
+            detail::span_copyable<T, E, U, N>::value, int>::type = 0>
+    explicit constexpr span(const span<U, N>& s) noexcept
+        : s_(s.data(), s.size()) { }
+
+    template<std::size_t C>
+    constexpr span<T, C> first() const {
+        static_assert(C <= E, "Count <= Extent");
+        return span<T, C>(s_.p, C);
+    }
+
+    template<std::size_t C>
+    constexpr span<T, C> last() const {
+        static_assert(C <= E, "Count <= Extent");
+        return span<T, C>(s_.p + (s_.n - C), C);
+    }
+
+    template<std::size_t O, std::size_t C = dynamic_extent>
+    constexpr typename std::enable_if<C == dynamic_extent,
+        span<T, detail::span_sub<E, O>::value> >::type subspan() const {
+        static_assert(O <= E, "Offset <= Extent");
+        return span<T, detail::span_sub<E, O>::value>(s_.p + O, s_.n - O);
+    }
+
+    template<std::size_t O, std::size_t C = dynamic_extent>
+    constexpr typename std::enable_if<C != dynamic_extent,
+        span<T, C> >::type subspan() const {
+        static_assert(O <= E && C <= E - O,
+            "Offset <= Extent && Count <= Extent - Offset");
+        return span<T, C>(s_.p + O, C);
+    }
+
+    constexpr span<T, dynamic_extent> first(size_type c) const {
+        return span<T, dynamic_extent>(s_.p, c);
+    }
+
+    constexpr span<T, dynamic_extent> last(size_type c) const {
+        return span<T, dynamic_extent>(s_.p + (s_.n - c), c);
+    }
+
+    constexpr span<T, dynamic_extent> subspan(size_type o,
+        size_type c = dynamic_extent) const {
+        return span<T, dynamic_extent>(s_.p + o,
+            c == dynamic_extent ? s_.n - o : c);
+    }
+
+    constexpr size_type size() const noexcept {
+        return s_.n;
+    }
+
+    constexpr size_type size_bytes() const noexcept {
+        return s_.n * sizeof(T);
+    }
+
+    constexpr bool empty() const noexcept {
+        return s_.n == 0;
+    }
+
+    constexpr reference operator[](size_type i) const {
+        return s_.p[i];
+    }
+
+    constexpr reference front() const {
+        return *s_.p;
+    }
+
+    constexpr reference back() const {
+        return s_.p[s_.n - 1];
+    }
+
+    constexpr pointer data() const noexcept {
+        return s_.p;
+    }
+
+    constexpr iterator begin() const noexcept {
+        return s_.p;
+    }
+
+    constexpr iterator end() const noexcept {
+        return s_.p + s_.n;
+    }
+
+    constexpr reverse_iterator rbegin() const noexcept {
+        return reverse_iterator(s_.p + s_.n);
+    }
+
+    constexpr reverse_iterator rend() const noexcept {
+        return reverse_iterator(s_.p);
+    }
+
+    constexpr const_iterator cbegin() const noexcept {
+        return s_.p;
+    }
+
+    constexpr const_iterator cend() const noexcept {
+        return s_.p + s_.n;
+    }
+
+    constexpr const_reverse_iterator crbegin() const noexcept {
+        return const_reverse_iterator(s_.p + s_.n);
+    }
+
+    constexpr const_reverse_iterator crend() const noexcept {
+        return const_reverse_iterator(s_.p);
+    }
+
+    friend constexpr iterator begin(span s) noexcept {
+        return s.begin();
+    }
+
+    friend constexpr iterator end(span s) noexcept {
+        return s.end();
+    }
+
+private:
+    detail::span_store<T, E> s_;
+};
+
+template<class T, std::size_t E>
+constexpr std::size_t span<T, E>::extent;
+
+#ifdef __cpp_deduction_guides
+template<class I, class L>
+span(I*, L) -> span<I>;
+
+template<class T, std::size_t N>
+span(T(&)[N]) -> span<T, N>;
+
+template<class T, std::size_t N>
+span(std::array<T, N>&) -> span<T, N>;
+
+template<class T, std::size_t N>
+span(const std::array<T, N>&) -> span<const T, N>;
+
+template<class R>
+span(R&&) -> span<typename detail::span_data<R>::type>;
+
+template<class T, std::size_t E>
+span(span<T, E>) -> span<T, E>;
+#endif
+
+#ifdef __cpp_lib_byte
+template<class T, std::size_t E>
+inline span<const std::byte, detail::span_bytes<T, E>::value>
+as_bytes(span<T, E> s) noexcept
+{
+    return span<const std::byte, detail::span_bytes<T,
+        E>::value>(reinterpret_cast<const std::byte*>(s.data()),
+            s.size_bytes());
+}
+
+template<class T, std::size_t E>
+inline typename std::enable_if<!std::is_const<T>::value,
+    span<std::byte, detail::span_bytes<T, E>::value> >::type
+as_writable_bytes(span<T, E> s) noexcept
+{
+    return span<std::byte, detail::span_bytes<T,
+        E>::value>(reinterpret_cast<std::byte*>(s.data()), s.size_bytes());
+}
+#endif
+
+} /* boost */
+
+#endif

include/boost/core/uncaught_exceptions.hpp

@@ -1,5 +1,5 @@
 /*
- *             Copyright Andrey Semashev 2018.
+ *          Copyright Andrey Semashev 2018 - 2020.
  * Distributed under the Boost Software License, Version 1.0.
  *    (See accompanying file LICENSE_1_0.txt or copy at
  *          https://www.boost.org/LICENSE_1_0.txt)
@@ -26,9 +26,24 @@
 #pragma once
 #endif
 
-// Visual Studio 14 supports N4152 std::uncaught_exceptions()
-#if (defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411) || \
-    (defined(_MSC_VER) && _MSC_VER >= 1900)
+#if (defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411)
+#if defined(__APPLE__)
+#include <Availability.h>
+// Apple systems only support std::uncaught_exceptions starting with specific versions:
+// - Mac OS >= 10.12
+// - iOS >= 10.0
+// - tvOS >= 10.0
+// - watchOS >= 3.0
+// https://github.com/boostorg/core/issues/80
+#if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200) || \
+    (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 100000)
+#define BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
+#endif
+#else
+#define BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
+#endif // defined(__APPLE__)
+// Visual Studio 14.0 supports N4152 std::uncaught_exceptions() but doesn't define __cpp_lib_uncaught_exceptions
+#elif (defined(_MSC_VER) && _MSC_VER >= 1900)
 #define BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
 #endif
 
@@ -46,7 +61,11 @@
 #if defined(BOOST_CORE_HAS_CXXABI_H)
 // MinGW GCC 4.4 seem to not work the same way the newer GCC versions do. As a result, __cxa_get_globals based implementation will always return 0.
 // Just disable it for now and fall back to std::uncaught_exception().
-#if !(defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 405))
+// On AIX, xlclang++ does have cxxabi.h but doesn't have __cxa_get_globals (https://github.com/boostorg/core/issues/78).
+#if !( \
+        (defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 405)) || \
+        defined(__ibmxl__) \
+    )
 #include <cxxabi.h>
 #include <cstring>
 #define BOOST_CORE_HAS_CXA_GET_GLOBALS
@@ -76,7 +95,7 @@ extern "C" __cxa_eh_globals* __cxa_get_globals() BOOST_NOEXCEPT_OR_NOTHROW __att
 #endif
 } // namespace __cxxabiv1
 #endif
-#endif // !(defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 405))
+#endif
 #endif // defined(BOOST_CORE_HAS_CXXABI_H)
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400

meta/libraries.json

@@ -8,14 +8,15 @@
         "Andrey Semashev"
     ],
     "maintainers": [
-        "Peter Dimov <pdimov -at- pdimov.com>",
+        "Peter Dimov <pdimov -at- gmail.com>",
         "Glen Fernandes <glenjofe -at- gmail.com>",
         "Andrey Semashev <andrey.semashev -at- gmail.com>"
     ],
     "description": "A collection of simple core utilities with minimal dependencies.",
     "category": [
         "Miscellaneous"
-    ]
+    ],
+    "cxxstd": "03"
     },
     {
         "key": "utility/enable_if",
@@ -33,7 +34,8 @@
         "maintainers": [
             "Jaakko Jarvi <jarvi -at- cs.tamu.edu>",
             "Jeremiah Willcock <jewillco -at- osl.iu.edu>"
-        ]
+        ],
+        "cxxstd": "03"
     },
     {
         "key": "utility/swap",
@@ -49,7 +51,8 @@
         ],
         "maintainers": [
             "Joseph Gauterin <joseph.gauterin -at- googlemail.com>"
-        ]
+        ],
+        "cxxstd": "03"
     },
     {
         "key": "bind/ref",
@@ -67,6 +70,7 @@
         ],
         "category": [
             "Function-objects"
-        ]
+        ],
+        "cxxstd": "03"
     }
 ]

test/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright 2018, 2019 Peter Dimov
+# Copyright 2018, 2019, 2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
@@ -6,7 +6,22 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
 
 if(HAVE_BOOST_TEST)
 
-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert Boost::type_traits Boost::throw_exception)
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert)
+
+set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::type_traits)
+
+boost_test(TYPE run SOURCES eif_constructors.cpp)
+boost_test(TYPE run SOURCES eif_dummy_arg_disambiguation.cpp)
+boost_test(TYPE run SOURCES eif_lazy.cpp)
+boost_test(TYPE run SOURCES eif_lazy_test.cpp)
+boost_test(TYPE run SOURCES eif_member_templates.cpp)
+boost_test(TYPE run SOURCES eif_namespace_disambiguation.cpp)
+boost_test(TYPE run SOURCES eif_no_disambiguation.cpp)
+boost_test(TYPE run SOURCES eif_partial_specializations.cpp)
+
+set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::throw_exception)
+
+boost_test(TYPE run SOURCES no_exceptions_support_test.cpp)
 
 endif()
 

test/Jamfile.v2

@@ -1,6 +1,6 @@
 #  Boost.Core Library test Jamfile
 #
-#  Copyright (c) 2014, 2017 Peter Dimov
+#  Copyright (c) 2014-2021 Peter Dimov
 #
 #  Distributed under the Boost Software License, Version 1.0.
 #  See accompanying file LICENSE_1_0.txt or copy at
@@ -9,6 +9,19 @@
 import modules ;
 import testing ;
 
+project : requirements
+
+  <warnings>extra
+  <toolset>msvc:<warnings-as-errors>on
+  <toolset>clang:<warnings-as-errors>on
+  <toolset>gcc:<warnings-as-errors>on
+  <toolset>gcc-4.4:<cxxflags>-Wno-sign-compare ;
+
+local warning-as-errors-off =
+    "-<toolset>msvc:<warnings-as-errors>on"
+    "-<toolset>gcc:<warnings-as-errors>on"
+    "-<toolset>clang:<warnings-as-errors>on" ;
+
 # quick test (for CI)
 run quick.cpp ;
 
@@ -18,48 +31,64 @@ run addressof_test2.cpp ;
 run addressof_np_test.cpp ;
 run addressof_fn_test.cpp ;
 compile addressof_constexpr_test.cpp ;
-compile-fail addressof_fail_rvalue.cpp ;
+compile-fail addressof_fail_rvalue.cpp
+  : $(warning-as-errors-off) ;
 
 run checked_delete_test.cpp ;
-compile-fail checked_delete_fail.cpp ;
-compile-fail checked_delete_fail2.cpp ;
+compile-fail checked_delete_fail.cpp
+  : $(warning-as-errors-off) ;
+compile-fail checked_delete_fail2.cpp
+  : $(warning-as-errors-off) ;
 
 compile ref_ct_test.cpp ;
 run ref_test.cpp ;
 run ref_ref_test.cpp ;
 run ref_fn_test.cpp ;
-compile-fail ref_rv_fail1.cpp ;
-compile-fail ref_rv_fail2.cpp ;
-compile-fail ref_rv_fail3.cpp ;
-compile-fail ref_rv_fail4.cpp ;
-compile-fail ref_rv_fail5.cpp ;
-compile-fail ref_implicit_fail.cpp ;
-compile-fail ref_implicit_fail2.cpp ;
+compile-fail ref_rv_fail1.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_rv_fail2.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_rv_fail3.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_rv_fail4.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_rv_fail5.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_implicit_fail.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_implicit_fail2.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_implicit_fail3.cpp
+  : $(warning-as-errors-off) ;
+compile-fail ref_implicit_fail4.cpp
+  : $(warning-as-errors-off) ;
 run ref_cv_test.cpp ;
+run ref_conversion_test.cpp ;
 
-run eif_constructors.cpp ;
-run eif_dummy_arg_disambiguation.cpp ;
-run eif_lazy.cpp ;
-run eif_lazy_test.cpp ;
-run eif_member_templates.cpp ;
-run eif_namespace_disambiguation.cpp ;
-run eif_no_disambiguation.cpp ;
-run eif_partial_specializations.cpp ;
+run eif_constructors.cpp : ;
+run eif_dummy_arg_disambiguation.cpp : ;
+run eif_lazy.cpp : ;
+run eif_lazy_test.cpp : ;
+run eif_member_templates.cpp : ;
+run eif_namespace_disambiguation.cpp : ;
+run eif_no_disambiguation.cpp : ;
+run eif_partial_specializations.cpp : ;
 
-compile-fail noncopyable_compile_fail.cpp ;
+compile-fail noncopyable_compile_fail.cpp
+  : $(warning-as-errors-off) ;
 
 run explicit_operator_bool.cpp ;
 run explicit_operator_bool_noexcept.cpp ;
-compile-fail explicit_operator_bool_compile_fail_conv_int.cpp ;
-compile-fail explicit_operator_bool_compile_fail_conv_pvoid.cpp ;
-compile-fail explicit_operator_bool_compile_fail_delete.cpp ;
-compile-fail explicit_operator_bool_compile_fail_shift.cpp ;
+compile-fail explicit_operator_bool_compile_fail_conv_int.cpp
+  : $(warning-as-errors-off) ;
+compile-fail explicit_operator_bool_compile_fail_conv_pvoid.cpp
+  : $(warning-as-errors-off) ;
+compile-fail explicit_operator_bool_compile_fail_delete.cpp
+  : $(warning-as-errors-off) ;
+compile-fail explicit_operator_bool_compile_fail_shift.cpp
+  : $(warning-as-errors-off) ;
 
-compile ignore_unused_test.cpp
-  : <warnings>extra
-    <toolset>gcc:<warnings-as-errors>on
-    <toolset>clang:<warnings-as-errors>on
-    <toolset>msvc:<warnings-as-errors>on ;
+compile ignore_unused_test.cpp ;
 
 run sp_typeinfo_test.cpp ;
 run sp_typeinfo_test.cpp : : : <rtti>off : sp_typeinfo_test_no_rtti ;
@@ -93,7 +122,11 @@ run lightweight_test_test4.cpp
   : : : $(pedantic-errors) ;
 run lightweight_test_test5.cpp
   : : : $(pedantic-errors)
-    <toolset>gcc-4.4.7:<cxxflags>-Wno-sign-compare ;
+    <toolset>gcc-4.4.7:<cxxflags>-Wno-sign-compare
+    <toolset>gcc-4.4:<cxxflags>-Wno-sign-compare
+  ;
+run lightweight_test_test6.cpp
+  : : : $(pedantic-errors) ;
 
 run-fail lightweight_test_all_eq_test.cpp ;
 run-fail lightweight_test_all_with_fail.cpp ;
@@ -105,15 +138,16 @@ run-fail lightweight_test_fail4.cpp ;
 run-fail lightweight_test_fail5.cpp ;
 run-fail lightweight_test_fail6.cpp ;
 run-fail lightweight_test_fail7.cpp ;
-run-fail lightweight_test_fail7.cpp : : : <rtti>off : lightweight_test_fail7_no_rtti ;
+run-fail lightweight_test_fail7.cpp : : : <rtti>off <toolset>gcc-4.4:<build>no : lightweight_test_fail7_no_rtti ;
 run-fail lightweight_test_fail8.cpp ;
-run-fail lightweight_test_fail8.cpp : : : <rtti>off : lightweight_test_fail8_no_rtti ;
+run-fail lightweight_test_fail8.cpp : : : <rtti>off <toolset>gcc-4.4:<build>no : lightweight_test_fail8_no_rtti ;
 run-fail lightweight_test_fail9.cpp ;
 run-fail lightweight_test_fail10.cpp ;
 run-fail lightweight_test_fail11.cpp : ;
 run-fail lightweight_test_fail12.cpp ;
 run-fail lightweight_test_fail13.cpp ;
 run-fail lightweight_test_fail14.cpp ;
+run-fail lightweight_test_fail15.cpp ;
 run-fail lightweight_test_lt_fail.cpp ;
 run-fail lightweight_test_le_fail.cpp ;
 run-fail lightweight_test_gt_fail.cpp ;
@@ -143,8 +177,10 @@ run demangled_name_test.cpp
 run demangled_name_test.cpp  : : : <rtti>off <test-info>always_show_run_output : demangled_name_test_no_rtti ;
 
 run scoped_enum.cpp ;
-compile-fail scoped_enum_compile_fail_conv_from_int.cpp ;
-compile-fail scoped_enum_compile_fail_conv_to_int.cpp ;
+compile-fail scoped_enum_compile_fail_conv_from_int.cpp
+  : $(warning-as-errors-off) ;
+compile-fail scoped_enum_compile_fail_conv_to_int.cpp
+  : $(warning-as-errors-off) ;
 
 run underlying_type.cpp ;
 
@@ -209,13 +245,68 @@ run test_lib_typeid.cpp lib_typeid : : : <link>static : test_lib_typeid_static ;
 run test_lib_typeid.cpp lib_typeid : : : <link>shared <rtti>off : test_lib_typeid_shared_no_rtti ;
 run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off : test_lib_typeid_static_no_rtti ;
 
+run test_lib_typeid2.cpp lib_typeid : : : <link>shared : test_lib_typeid2_shared ;
+run test_lib_typeid2.cpp lib_typeid : : : <link>static : test_lib_typeid2_static ;
+
+run test_lib_typeid2.cpp lib_typeid : : : <link>shared <rtti>off : test_lib_typeid2_shared_no_rtti ;
+run test_lib_typeid2.cpp lib_typeid : : : <link>static <rtti>off : test_lib_typeid2_static_no_rtti ;
+
 run uncaught_exceptions.cpp
   : : : <exception-handling>on ;
 run uncaught_exceptions_np.cpp
   : : : <exception-handling>on ;
 
-run no_exceptions_support_test.cpp ;
+run no_exceptions_support_test.cpp : ;
 run no_exceptions_support_test.cpp : : : <exception-handling>off : no_exceptions_support_test_nx ;
 
+run cmath_test.cpp ;
+run cmath_test.cpp : : : <define>BOOST_CORE_USE_GENERIC_CMATH <toolset>msvc-8.0:<build>no : cmath_test_generic ;
+
+run bit_cast_test.cpp ;
+run bit_rotate_test.cpp ;
+run bit_countr_test.cpp ;
+run bit_countl_test.cpp ;
+run bit_width_test.cpp ;
+run has_single_bit_test.cpp ;
+run bit_floor_test.cpp ;
+run bit_ceil_test.cpp ;
+run bit_popcount_test.cpp ;
+run bit_endian_test.cpp ;
+
+run type_name_test.cpp ;
+
+run sv_types_test.cpp ;
+run sv_construct_test.cpp ;
+run sv_iteration_test.cpp ;
+run sv_element_access_test.cpp ;
+run sv_modifiers_test.cpp ;
+run sv_copy_test.cpp ;
+run sv_substr_test.cpp ;
+run sv_compare_test.cpp ;
+run sv_starts_with_test.cpp ;
+run sv_ends_with_test.cpp ;
+run sv_find_test.cpp ;
+run sv_rfind_test.cpp ;
+run sv_find_first_of_test.cpp
+  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+run sv_find_last_of_test.cpp
+  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+run sv_find_first_not_of_test.cpp
+  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+run sv_find_last_not_of_test.cpp
+  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+run sv_contains_test.cpp ;
+run sv_eq_test.cpp ;
+run sv_lt_test.cpp ;
+run sv_stream_insert_test.cpp ;
+run sv_conversion_test.cpp ;
+
+run span_test.cpp ;
+run span_types_test.cpp ;
+run span_constructible_test.cpp ;
+run span_deduction_guide_test.cpp ;
+run as_bytes_test.cpp ;
+run as_writable_bytes_test.cpp ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/alloc_construct_cxx11_test.cpp

@@ -10,6 +10,10 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/alloc_construct.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4100) // unreferenced parameter 'ptr'
+#endif
+
 class type {
 public:
     explicit type(int x)

test/allocator_size_type_test.cpp

@@ -27,7 +27,8 @@ int main()
     BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
         boost::allocator_size_type<A1<char> >::type>));
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::size_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<
+        std::make_unsigned<std::ptrdiff_t>::type,
         boost::allocator_size_type<A2<int> >::type>));
 #endif
     return boost::report_errors();

test/as_bytes_test.cpp

@@ -0,0 +1,42 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <cstddef>
+#ifdef __cpp_lib_byte
+#include <boost/core/span.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+void test_dynamic()
+{
+    int a[4];
+    boost::span<const std::byte> s =
+        boost::as_bytes(boost::span<int>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), reinterpret_cast<const std::byte*>(&a[0]));
+    BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
+}
+
+void test_static()
+{
+    int a[4];
+    boost::span<const std::byte, sizeof(int) * 4> s =
+        boost::as_bytes(boost::span<int, 4>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), reinterpret_cast<const std::byte*>(&a[0]));
+    BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
+}
+
+int main()
+{
+    test_dynamic();
+    test_static();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/as_writable_bytes_test.cpp

@@ -0,0 +1,42 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <cstddef>
+#ifdef __cpp_lib_byte
+#include <boost/core/span.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+void test_dynamic()
+{
+    int a[4];
+    boost::span<std::byte> s =
+        boost::as_writable_bytes(boost::span<int>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), reinterpret_cast<std::byte*>(&a[0]));
+    BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
+}
+
+void test_static()
+{
+    int a[4];
+    boost::span<std::byte, sizeof(int) * 4> s =
+        boost::as_writable_bytes(boost::span<int, 4>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), reinterpret_cast<std::byte*>(&a[0]));
+    BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
+}
+
+int main()
+{
+    test_dynamic();
+    test_static();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/bit_cast_test.cpp

@@ -0,0 +1,29 @@
+// Test for boost/core/bit.hpp (bit_cast)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+#include <cstring>
+
+int main()
+{
+    {
+        float x = 0.89f;
+        boost::uint32_t y = boost::core::bit_cast<boost::uint32_t>( x );
+
+        BOOST_TEST( std::memcmp( &x, &y, sizeof(x) ) == 0 );
+    }
+
+    {
+        double x = 0.89;
+        boost::uint64_t y = boost::core::bit_cast<boost::uint64_t>( x );
+
+        BOOST_TEST( std::memcmp( &x, &y, sizeof(x) ) == 0 );
+    }
+
+    return boost::report_errors();
+}

test/bit_ceil_test.cpp

@@ -0,0 +1,65 @@
+// Test for boost/core/bit.hpp (bit_ceil)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+template<class T> void test_bit_ceil( T x )
+{
+    if( !boost::core::has_single_bit( x ) )
+    {
+        x >>= 1;
+    }
+
+    T y = boost::core::bit_ceil( x );
+
+    if( x == 0 )
+    {
+        BOOST_TEST_EQ( y, 0 );
+    }
+    else
+    {
+        BOOST_TEST( boost::core::has_single_bit( y ) );
+        BOOST_TEST_GE( +y, +x );
+        BOOST_TEST_LT( y >> 1, +x );
+    }
+}
+
+int main()
+{
+    {
+        test_bit_ceil( static_cast<unsigned char>( 0 ) );
+        test_bit_ceil( static_cast<unsigned short>( 0 ) );
+        test_bit_ceil( static_cast<unsigned int>( 0 ) );
+        test_bit_ceil( static_cast<unsigned long>( 0 ) );
+        test_bit_ceil( static_cast<unsigned long long>( 0 ) );
+    }
+
+    {
+        test_bit_ceil( static_cast<boost::uint8_t>( 0x80 ) );
+        test_bit_ceil( static_cast<boost::uint16_t>( 0x8000 ) );
+        test_bit_ceil( static_cast<boost::uint32_t>( 0x80000000 ) );
+        test_bit_ceil( static_cast<boost::uint64_t>( 0x8000000000000000 ) );
+    }
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_bit_ceil( static_cast<unsigned char>( x ) );
+        test_bit_ceil( static_cast<unsigned short>( x ) );
+        test_bit_ceil( static_cast<unsigned int>( x ) );
+        test_bit_ceil( static_cast<unsigned long>( x ) );
+        test_bit_ceil( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/bit_countl_test.cpp

@@ -0,0 +1,46 @@
+// Test for boost/core/bit.hpp (countl_zero, countl_one)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+template<class T> void test_countl( T x )
+{
+    x |= static_cast<T>( 1 ) << ( std::numeric_limits<T>::digits - 1 );
+
+    for( int i = 0; i <= std::numeric_limits<T>::digits; ++i, x >>= 1 )
+    {
+        BOOST_TEST_EQ( boost::core::countl_zero( x ), i );
+        BOOST_TEST_EQ( boost::core::countl_one( static_cast<T>( ~x ) ), i );
+    }
+}
+
+int main()
+{
+    test_countl( static_cast<unsigned char>( 0 ) );
+    test_countl( static_cast<unsigned short>( 0 ) );
+    test_countl( static_cast<unsigned int>( 0 ) );
+    test_countl( static_cast<unsigned long>( 0 ) );
+    test_countl( static_cast<unsigned long long>( 0 ) );
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_countl( static_cast<unsigned char>( x ) );
+        test_countl( static_cast<unsigned short>( x ) );
+        test_countl( static_cast<unsigned int>( x ) );
+        test_countl( static_cast<unsigned long>( x ) );
+        test_countl( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/bit_countr_test.cpp

@@ -0,0 +1,46 @@
+// Test for boost/core/bit.hpp (countr_zero, countr_one)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+template<class T> void test_countr( T x )
+{
+    x |= 1;
+
+    for( int i = 0; i <= std::numeric_limits<T>::digits; ++i, x <<= 1 )
+    {
+        BOOST_TEST_EQ( boost::core::countr_zero( x ), i );
+        BOOST_TEST_EQ( boost::core::countr_one( static_cast<T>( ~x ) ), i );
+    }
+}
+
+int main()
+{
+    test_countr( static_cast<unsigned char>( 0 ) );
+    test_countr( static_cast<unsigned short>( 0 ) );
+    test_countr( static_cast<unsigned int>( 0 ) );
+    test_countr( static_cast<unsigned long>( 0 ) );
+    test_countr( static_cast<unsigned long long>( 0 ) );
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_countr( static_cast<unsigned char>( x ) );
+        test_countr( static_cast<unsigned short>( x ) );
+        test_countr( static_cast<unsigned int>( x ) );
+        test_countr( static_cast<unsigned long>( x ) );
+        test_countr( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/bit_endian_test.cpp

@@ -0,0 +1,40 @@
+// Test for boost/core/bit.hpp (bit_ceil)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+#include <cstring>
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4127) // conditional expression is constant
+#endif
+
+int main()
+{
+    boost::uint64_t v = static_cast<boost::uint64_t>( 0x0102030405060708ull );
+
+    if( boost::core::endian::native == boost::core::endian::little )
+    {
+        unsigned char w[] = { 8, 7, 6, 5, 4, 3, 2, 1 };
+        BOOST_TEST( std::memcmp( &v, w, 8 ) == 0 );
+    }
+    else if( boost::core::endian::native == boost::core::endian::big )
+    {
+        unsigned char w[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+        BOOST_TEST( std::memcmp( &v, w, 8 ) == 0 );
+    }
+    else
+    {
+        unsigned char w1[] = { 8, 7, 6, 5, 4, 3, 2, 1 };
+        BOOST_TEST( std::memcmp( &v, w1, 8 ) != 0 );
+
+        unsigned char w2[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+        BOOST_TEST( std::memcmp( &v, w2, 8 ) != 0 );
+    }
+
+    return boost::report_errors();
+}

test/bit_floor_test.cpp

@@ -0,0 +1,53 @@
+// Test for boost/core/bit.hpp (bit_floor)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+template<class T> void test_bit_floor( T x )
+{
+    T y = boost::core::bit_floor( x );
+
+    if( x == 0 )
+    {
+        BOOST_TEST_EQ( y, 0 );
+    }
+    else
+    {
+        BOOST_TEST( boost::core::has_single_bit( y ) );
+        BOOST_TEST_LE( +y, +x );
+        BOOST_TEST_GT( +y, x >> 1 );
+    }
+}
+
+int main()
+{
+    {
+        test_bit_floor( static_cast<unsigned char>( 0 ) );
+        test_bit_floor( static_cast<unsigned short>( 0 ) );
+        test_bit_floor( static_cast<unsigned int>( 0 ) );
+        test_bit_floor( static_cast<unsigned long>( 0 ) );
+        test_bit_floor( static_cast<unsigned long long>( 0 ) );
+    }
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_bit_floor( static_cast<unsigned char>( x ) );
+        test_bit_floor( static_cast<unsigned short>( x ) );
+        test_bit_floor( static_cast<unsigned int>( x ) );
+        test_bit_floor( static_cast<unsigned long>( x ) );
+        test_bit_floor( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/bit_popcount_test.cpp

@@ -0,0 +1,46 @@
+// Test for boost/core/bit.hpp (bit_ceil)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+#include <iostream>
+
+template<class T> void test_popcount( T x )
+{
+    int k = 0;
+    for( T y = x; y; y &= y - 1, ++k );
+
+    BOOST_TEST_EQ( boost::core::popcount( x ), k ) || ( std::cerr << "x: " << +x << std::endl );
+}
+
+int main()
+{
+    {
+        test_popcount( static_cast<unsigned char>( 0 ) );
+        test_popcount( static_cast<unsigned short>( 0 ) );
+        test_popcount( static_cast<unsigned int>( 0 ) );
+        test_popcount( static_cast<unsigned long>( 0 ) );
+        test_popcount( static_cast<unsigned long long>( 0 ) );
+    }
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_popcount( static_cast<unsigned char>( x ) );
+        test_popcount( static_cast<unsigned short>( x ) );
+        test_popcount( static_cast<unsigned int>( x ) );
+        test_popcount( static_cast<unsigned long>( x ) );
+        test_popcount( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/bit_rotate_test.cpp

@@ -0,0 +1,175 @@
+// Test for boost/core/bit.hpp (rotl, rotr)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+int const M = 256;
+
+template<class T> void test_rotate( T x )
+{
+    for( int i = 0; i < M; ++i )
+    {
+        BOOST_TEST_EQ( +boost::core::rotl( x, i ), +boost::core::rotr( x, -i ) );
+        BOOST_TEST_EQ( +boost::core::rotl( x, -i ), +boost::core::rotr( x, i ) );
+
+        unsigned const width = std::numeric_limits<T>::digits;
+        unsigned r = i & ( width - 1 );
+
+        if( r == 0 )
+        {
+            BOOST_TEST_EQ( +boost::core::rotl( x, i ), +x );
+            BOOST_TEST_EQ( +boost::core::rotr( x, i ), +x );
+        }
+        else
+        {
+            BOOST_TEST_EQ( +boost::core::rotl( x, i ), +static_cast<T>( (x << r) | (x >> (width - r)) ) );
+            BOOST_TEST_EQ( +boost::core::rotr( x, i ), +static_cast<T>( (x >> r) | (x << (width - r)) ) );
+        }
+    }
+}
+
+int main()
+{
+    {
+        boost::uint8_t x = 0x11;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x22 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x88 );
+
+        x = 0x22;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x44 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x11 );
+
+        x = 0x44;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x88 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x22 );
+
+        x = 0x88;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x11 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x44 );
+    }
+
+    {
+        boost::uint16_t x = 0x1111;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x2222 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x8888 );
+
+        x = 0x2222;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x4444 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x1111 );
+
+        x = 0x4444;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x8888 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x2222 );
+
+        x = 0x8888;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x1111 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x4444 );
+    }
+
+    {
+        boost::uint32_t x = 0x11111111;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x22222222 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x88888888 );
+
+        x = 0x22222222;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x44444444 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x11111111 );
+
+        x = 0x44444444;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x88888888 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x22222222 );
+
+        x = 0x88888888;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x11111111 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x44444444 );
+    }
+
+    {
+        boost::uint64_t x = 0x1111111111111111;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x2222222222222222 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x8888888888888888 );
+
+        x = 0x2222222222222222;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x4444444444444444 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x1111111111111111 );
+
+        x = 0x4444444444444444;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x8888888888888888 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x2222222222222222 );
+
+        x = 0x8888888888888888;
+
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x1111111111111111 );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x4444444444444444 );
+    }
+
+    for( int i = -M; i <= M; ++i )
+    {
+        {
+            unsigned char x = 0;
+            BOOST_TEST_EQ( +boost::core::rotl( x, i ), +x );
+            BOOST_TEST_EQ( +boost::core::rotr( x, i ), +x );
+        }
+
+        {
+            unsigned short x = 0;
+            BOOST_TEST_EQ( boost::core::rotl( x, i ), x );
+            BOOST_TEST_EQ( boost::core::rotr( x, i ), x );
+        }
+
+        {
+            unsigned int x = 0;
+            BOOST_TEST_EQ( boost::core::rotl( x, i ), x );
+            BOOST_TEST_EQ( boost::core::rotr( x, i ), x );
+        }
+
+        {
+            unsigned long x = 0;
+            BOOST_TEST_EQ( boost::core::rotl( x, i ), x );
+            BOOST_TEST_EQ( boost::core::rotr( x, i ), x );
+        }
+
+        {
+            unsigned long long x = 0;
+            BOOST_TEST_EQ( boost::core::rotl( x, i ), x );
+            BOOST_TEST_EQ( boost::core::rotr( x, i ), x );
+        }
+    }
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_rotate( static_cast<unsigned char>( x ) );
+        test_rotate( static_cast<unsigned short>( x ) );
+        test_rotate( static_cast<unsigned int>( x ) );
+        test_rotate( static_cast<unsigned long>( x ) );
+        test_rotate( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/bit_width_test.cpp

@@ -0,0 +1,94 @@
+// Test for boost/core/bit.hpp (bit_width)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+template<class T> void test_width( T x )
+{
+    BOOST_TEST_EQ( boost::core::bit_width( x ), std::numeric_limits<T>::digits - boost::core::countl_zero( x ) );
+}
+
+int main()
+{
+    {
+        boost::uint8_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::bit_width( x ), 0 );
+
+        x = 1;
+
+        for( int i = 0; i < 8; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::bit_width( x ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint8_t>( x | ( x >> 1 ) ) ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint8_t>( x | ( x >> 2 ) ) ), i+1 );
+        }
+    }
+
+    {
+        boost::uint16_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::bit_width( x ), 0 );
+
+        x = 1;
+
+        for( int i = 0; i < 16; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::bit_width( x ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint16_t>( x | ( x >> 1 ) ) ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint16_t>( x | ( x >> 2 ) ) ), i+1 );
+        }
+    }
+
+    {
+        boost::uint32_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::bit_width( x ), 0 );
+
+        x = 1;
+
+        for( int i = 0; i < 32; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::bit_width( x ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint32_t>( x | ( x >> 1 ) ) ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint32_t>( x | ( x >> 2 ) ) ), i+1 );
+        }
+    }
+
+    {
+        boost::uint64_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::bit_width( x ), 0 );
+
+        x = 1;
+
+        for( int i = 0; i < 64; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::bit_width( x ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint64_t>( x | ( x >> 1 ) ) ), i+1 );
+            BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint64_t>( x | ( x >> 2 ) ) ), i+1 );
+        }
+    }
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_width( static_cast<unsigned char>( x ) );
+        test_width( static_cast<unsigned short>( x ) );
+        test_width( static_cast<unsigned int>( x ) );
+        test_width( static_cast<unsigned long>( x ) );
+        test_width( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/cmake_subdir_test/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright 2018, 2019 Peter Dimov
+# Copyright 2018, 2019, 2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
@@ -9,6 +9,8 @@ project(cmake_subdir_test LANGUAGES CXX)
 add_subdirectory(../.. boostorg/core)
 add_subdirectory(../../../assert boostorg/assert)
 add_subdirectory(../../../config boostorg/config)
+add_subdirectory(../../../static_assert boostorg/static_assert)
+add_subdirectory(../../../throw_exception boostorg/throw_exception)
 
 add_executable(quick ../quick.cpp)
 target_link_libraries(quick Boost::core)

test/cmath_test.cpp

@@ -0,0 +1,296 @@
+// Test for boost/core/cmath.hpp
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/cmath.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <limits>
+#include <cfloat>
+
+template<class T> void test_positive_normal( T x )
+{
+    BOOST_TEST( boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_normal );
+
+    BOOST_TEST( !boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(+2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(+2) );
+}
+
+template<class T> void test_negative_normal( T x )
+{
+    BOOST_TEST( boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_normal );
+
+    BOOST_TEST( boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(-2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(-2) );
+}
+
+template<class T> void test_positive_zero( T x )
+{
+    BOOST_TEST( boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_zero );
+
+    BOOST_TEST( !boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(+2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(+2) );
+}
+
+template<class T> void test_negative_zero( T x )
+{
+    BOOST_TEST( boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_zero );
+
+#if defined(BOOST_CORE_USE_GENERIC_CMATH) && BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+    // g++ 4.4, 4.6 fail these tests with optimizations on
+
+#else
+
+    BOOST_TEST( boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(-2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(-2) );
+
+#endif
+}
+
+template<class T> void test_positive_infinity( T x )
+{
+    BOOST_TEST( !boost::core::isfinite( x ) );
+    BOOST_TEST( boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_infinite );
+
+    BOOST_TEST( !boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(+2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(+2) );
+}
+
+template<class T> void test_negative_infinity( T x )
+{
+    BOOST_TEST( !boost::core::isfinite( x ) );
+    BOOST_TEST( boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_infinite );
+
+    BOOST_TEST( boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(-2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(-2) );
+}
+
+template<class T> void test_positive_nan( T x )
+{
+    BOOST_TEST( !boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_nan );
+
+    BOOST_TEST( !boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(+2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(+2) );
+}
+
+template<class T> void test_negative_nan( T x )
+{
+    BOOST_TEST( !boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_nan );
+
+    BOOST_TEST( boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(-2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(-2) );
+}
+
+template<class T> void test_positive_subnormal( T x )
+{
+    BOOST_TEST( boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_subnormal );
+
+    BOOST_TEST( !boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(+2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(+2) );
+}
+
+template<class T> void test_negative_subnormal( T x )
+{
+    BOOST_TEST( boost::core::isfinite( x ) );
+    BOOST_TEST( !boost::core::isinf( x ) );
+    BOOST_TEST( !boost::core::isnan( x ) );
+    BOOST_TEST( !boost::core::isnormal( x ) );
+
+    BOOST_TEST_EQ( boost::core::fpclassify( x ), boost::core::fp_subnormal );
+
+    BOOST_TEST( boost::core::signbit( x ) );
+
+    BOOST_TEST_EQ( boost::core::copysign( T(+2), x ), T(-2) );
+    BOOST_TEST_EQ( boost::core::copysign( T(-2), x ), T(-2) );
+}
+
+template<class T> void test_positive_normal_( T x )
+{
+    test_positive_normal( x );
+    test_positive_normal( boost::core::copysign( x, T(+1) ) );
+    test_negative_normal( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_negative_normal_( T x )
+{
+    test_negative_normal( x );
+    test_positive_normal( boost::core::copysign( x, T(+1) ) );
+    test_negative_normal( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_positive_zero_( T x )
+{
+    test_positive_zero( x );
+    test_positive_zero( boost::core::copysign( x, T(+1) ) );
+    test_negative_zero( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_negative_zero_( T x )
+{
+    test_negative_zero( x );
+    test_positive_zero( boost::core::copysign( x, T(+1) ) );
+    test_negative_zero( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_positive_infinity_( T x )
+{
+    test_positive_infinity( x );
+    test_positive_infinity( boost::core::copysign( x, T(+1) ) );
+    test_negative_infinity( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_negative_infinity_( T x )
+{
+    test_negative_infinity( x );
+    test_positive_infinity( boost::core::copysign( x, T(+1) ) );
+    test_negative_infinity( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_positive_nan_( T x )
+{
+    test_positive_nan( x );
+    test_positive_nan( boost::core::copysign( x, T(+1) ) );
+    test_negative_nan( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_negative_nan_( T x )
+{
+    test_negative_nan( x );
+    test_positive_nan( boost::core::copysign( x, T(+1) ) );
+    test_negative_nan( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_positive_subnormal_( T x )
+{
+    test_positive_subnormal( x );
+    test_positive_subnormal( boost::core::copysign( x, T(+1) ) );
+    test_negative_subnormal( boost::core::copysign( x, T(-1) ) );
+}
+
+template<class T> void test_negative_subnormal_( T x )
+{
+    test_negative_subnormal( x );
+    test_positive_subnormal( boost::core::copysign( x, T(+1) ) );
+    test_negative_subnormal( boost::core::copysign( x, T(-1) ) );
+}
+
+int main()
+{
+    // float
+
+    test_positive_normal_( +1.0f );
+    test_negative_normal_( -1.0f );
+    test_positive_normal_( FLT_MIN );
+    test_negative_normal_( -FLT_MIN );
+    test_positive_normal_( FLT_MAX );
+    test_negative_normal_( -FLT_MAX );
+    test_positive_zero_( +0.0f );
+    test_negative_zero_( -0.0f );
+    test_positive_infinity_( std::numeric_limits<float>::infinity() );
+    test_negative_infinity_( -std::numeric_limits<float>::infinity() );
+    test_positive_nan_( std::numeric_limits<float>::quiet_NaN() );
+    test_negative_nan_( boost::core::copysign( std::numeric_limits<float>::quiet_NaN(), -1.0f ) );
+    test_positive_subnormal_( FLT_MIN / 2 );
+    test_negative_subnormal_( -FLT_MIN / 2 );
+
+    // double
+
+    test_positive_normal_( +1.0 );
+    test_negative_normal_( -1.0 );
+    test_positive_normal_( DBL_MIN );
+    test_negative_normal_( -DBL_MIN );
+    test_positive_normal_( DBL_MAX );
+    test_negative_normal_( -DBL_MAX );
+    test_positive_zero_( +0.0 );
+    test_negative_zero_( -0.0 );
+    test_positive_infinity_( std::numeric_limits<double>::infinity() );
+    test_negative_infinity_( -std::numeric_limits<double>::infinity() );
+    test_positive_nan_( std::numeric_limits<double>::quiet_NaN() );
+    test_negative_nan_( boost::core::copysign( std::numeric_limits<double>::quiet_NaN(), -1.0 ) );
+    test_positive_subnormal_( DBL_MIN / 2 );
+    test_negative_subnormal_( -DBL_MIN / 2 );
+
+    // long double
+
+    test_positive_normal_( +1.0l );
+    test_negative_normal_( -1.0l );
+    test_positive_normal_( LDBL_MIN );
+    test_negative_normal_( -LDBL_MIN );
+    test_positive_normal_( LDBL_MAX );
+    test_negative_normal_( -LDBL_MAX );
+    test_positive_zero_( +0.0l );
+    test_negative_zero_( -0.0l );
+    test_positive_infinity_( std::numeric_limits<long double>::infinity() );
+    test_negative_infinity_( -std::numeric_limits<long double>::infinity() );
+    test_positive_nan_( std::numeric_limits<long double>::quiet_NaN() );
+    test_negative_nan_( boost::core::copysign( std::numeric_limits<long double>::quiet_NaN(), -1.0l ) );
+    test_positive_subnormal_( LDBL_MIN / 2 );
+    test_negative_subnormal_( -LDBL_MIN / 2 );
+
+    return boost::report_errors();
+}

test/eif_constructors.cpp

@@ -13,6 +13,7 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <cstddef>
 
 using boost::enable_if;
 using boost::disable_if;
@@ -39,7 +40,7 @@ struct xstring
           disable_if<is_arithmetic<It> >::type* = 0)
     : data(end-begin) {}
   
-  int data;
+  std::ptrdiff_t data;
 };
 
 
@@ -58,4 +59,3 @@ int main()
 
   return boost::report_errors();
 }
-

test/eif_dummy_arg_disambiguation.cpp

@@ -24,11 +24,11 @@ template <int N> struct dummy {
 
 template<class T>
 typename enable_if<is_arithmetic<T>, bool>::type
-arithmetic_object(T t, dummy<0> = 0) { return true; }
+arithmetic_object(T /*t*/, dummy<0> = 0) { return true; }
 
 template<class T>
 typename disable_if<is_arithmetic<T>, bool>::type
-arithmetic_object(T t, dummy<1> = 0) { return false; }
+arithmetic_object(T /*t*/, dummy<1> = 0) { return false; }
 
 
 int main()
@@ -42,4 +42,3 @@ int main()
 
   return boost::report_errors();
 }
-

test/eif_lazy_test.cpp

@@ -60,21 +60,21 @@ namespace A {
 
   template<class T>
   typename lazy_enable_if<is_int_or_double<T>, some_traits<T> >::type
-  foo(T t) { return true; }
+  foo(T /*t*/) { return true; }
 
   template<class T>
   typename lazy_enable_if_c<is_int_or_double<T>::value, some_traits<T> >::type
-  foo2(T t) { return true; }
+  foo2(T /*t*/) { return true; }
 }
 
 namespace B {
   template<class T>
   typename lazy_disable_if<is_int_or_double<T>, make_bool<T> >::type
-  foo(T t) { return false; }
+  foo(T /*t*/) { return false; }
 
   template<class T>
   typename lazy_disable_if_c<is_int_or_double<T>::value, make_bool<T> >::type
-  foo2(T t) { return false; }
+  foo2(T /*t*/) { return false; }
 }
 
 int main()
@@ -95,4 +95,3 @@ int main()
 
   return boost::report_errors();
 }
-

test/eif_namespace_disambiguation.cpp

@@ -26,13 +26,13 @@ template<class T> struct not_
 namespace A {
   template<class T>
   typename enable_if<is_arithmetic<T>, bool>::type
-  arithmetic_object(T t) { return true; }
+  arithmetic_object(T /*t*/) { return true; }
 }
 
 namespace B {
   template<class T>
   typename enable_if<not_<is_arithmetic<T> >, bool>::type
-  arithmetic_object(T t) { return false; }
+  arithmetic_object(T /*t*/) { return false; }
 }
 
 int main()
@@ -47,4 +47,3 @@ int main()
 
   return boost::report_errors();
 }
-

test/eif_no_disambiguation.cpp

@@ -25,11 +25,11 @@ template<class T> struct not_
 
 template<class T>
 typename enable_if<is_arithmetic<T>, bool>::type
-arithmetic_object(T t) { return true; }
+arithmetic_object(T /*t*/) { return true; }
 
 template<class T>
 typename enable_if<not_<is_arithmetic<T> >, bool>::type
-arithmetic_object(T t) { return false; }
+arithmetic_object(T /*t*/) { return false; }
 
 
 int main()
@@ -43,4 +43,3 @@ int main()
 
   return boost::report_errors();
 }
-

test/explicit_operator_bool_noexcept.cpp

@@ -76,6 +76,11 @@ int main(int, char*[])
     BOOST_TEST(noexcept(static_cast< bool >(noexcept_val1)));
     BOOST_TEST(noexcept(static_cast< bool >(noexcept_val2)));
 
+    (void)val1;
+    (void)val2;
+    (void)noexcept_val1;
+    (void)noexcept_val2;
+
     return boost::report_errors();
 }
 

test/get_pointer_test.cpp

@@ -8,6 +8,10 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // std::auto_ptr
+#endif
+
 #include <boost/get_pointer.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <memory>

test/has_single_bit_test.cpp

@@ -0,0 +1,110 @@
+// Test for boost/core/bit.hpp (has_single_bit)
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+template<class T> void test_single_bit( T x )
+{
+    BOOST_TEST_EQ( boost::core::has_single_bit( x ), boost::core::popcount( x ) == 1 );
+}
+
+int main()
+{
+    {
+        boost::uint8_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), false );
+
+        x = 1;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+
+        x = 2;
+
+        for( int i = 1; i < 8; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint8_t>( x | ( x >> 1 ) ) ), false );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint8_t>( x | ( x >> 1 ) | ( x >> 2 ) ) ), false );
+        }
+    }
+
+    {
+        boost::uint16_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), false );
+
+        x = 1;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+
+        x = 2;
+
+        for( int i = 1; i < 16; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint16_t>( x | ( x >> 1 ) ) ), false );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint16_t>( x | ( x >> 1 ) | ( x >> 2 ) ) ), false );
+        }
+    }
+
+    {
+        boost::uint32_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), false );
+
+        x = 1;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+
+        x = 2;
+
+        for( int i = 1; i < 32; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint32_t>( x | ( x >> 1 ) ) ), false );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint32_t>( x | ( x >> 1 ) | ( x >> 2 ) ) ), false );
+        }
+    }
+
+    {
+        boost::uint64_t x = 0;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), false );
+
+        x = 1;
+
+        BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+
+        x = 2;
+
+        for( int i = 1; i < 64; ++i, x <<= 1 )
+        {
+            BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint64_t>( x | ( x >> 1 ) ) ), false );
+            BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint64_t>( x | ( x >> 1 ) | ( x >> 2 ) ) ), false );
+        }
+    }
+
+    boost::detail::splitmix64 rng;
+
+    for( int i = 0; i < 1000; ++i )
+    {
+        boost::uint64_t x = rng();
+
+        test_single_bit( static_cast<unsigned char>( x ) );
+        test_single_bit( static_cast<unsigned short>( x ) );
+        test_single_bit( static_cast<unsigned int>( x ) );
+        test_single_bit( static_cast<unsigned long>( x ) );
+        test_single_bit( static_cast<unsigned long long>( x ) );
+    }
+
+    return boost::report_errors();
+}

test/iterator_test.cpp

@@ -8,6 +8,8 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING
+
 #include <boost/iterator.hpp>
 #include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

test/lib_typeid.cpp

@@ -15,3 +15,12 @@ EXPORT boost::core::typeinfo const & get_typeid_int()
 {
     return BOOST_CORE_TYPEID( int );
 }
+
+struct BOOST_SYMBOL_VISIBLE X
+{
+};
+
+EXPORT boost::core::typeinfo const & get_typeid_X()
+{
+    return BOOST_CORE_TYPEID( X );
+}

test/lightweight_test_fail10.cpp

@@ -8,6 +8,10 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wstring-plus-int"
+#endif
+
 #include <boost/core/lightweight_test.hpp>
 
 int main()

test/lightweight_test_fail15.cpp

@@ -0,0 +1,37 @@
+// Test BOOST_TEST_NE with character types
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+int main()
+{
+    BOOST_TEST_NE( 'A', 'A' );
+    BOOST_TEST_NE( (char)1, (char)1 );
+    BOOST_TEST_NE( (unsigned char)1, (unsigned char)1 );
+    BOOST_TEST_NE( (signed char)-1, (signed char)-1 );
+
+    BOOST_TEST_NE( L'A', L'A' );
+    BOOST_TEST_NE( (wchar_t)1, (wchar_t)1 );
+
+    int exp = 6;
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+
+    BOOST_TEST_NE( (char16_t)1, (char16_t)1 );
+    ++exp;
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+
+    BOOST_TEST_NE( (char32_t)1, (char32_t)1 );
+    ++exp;
+
+#endif
+
+    return boost::report_errors() == exp;
+}

test/lightweight_test_fail6.cpp

@@ -8,6 +8,10 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 #include <boost/core/lightweight_test.hpp>
 
 struct X

test/lightweight_test_test6.cpp

@@ -0,0 +1,33 @@
+// Test BOOST_TEST_EQ with character types
+//
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( 'A', 'A' );
+    BOOST_TEST_EQ( (char)1, (char)1 );
+    BOOST_TEST_EQ( (unsigned char)1, (unsigned char)1 );
+    BOOST_TEST_EQ( (signed char)-1, (signed char)-1 );
+
+    BOOST_TEST_EQ( L'A', L'A' );
+    BOOST_TEST_EQ( (wchar_t)1, (wchar_t)1 );
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+
+    BOOST_TEST_EQ( (char16_t)1, (char16_t)1 );
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+
+    BOOST_TEST_EQ( (char32_t)1, (char32_t)1 );
+
+#endif
+
+    return boost::report_errors();
+}

test/lightweight_test_with_fail.cpp

@@ -13,17 +13,17 @@ template <typename T>
 struct with_tolerance
 {
     with_tolerance( T tolerance ): tolerance( tolerance )
-	{
-	}
+    {
+    }
 
-	bool operator()( T lhs, T rhs ) const
+    bool operator()( T lhs, T rhs ) const
     {
         return std::abs( lhs - rhs ) <= tolerance;
     }
 
 private:
 
-	T tolerance;
+    T tolerance;
 };
 
 void test_tolerance_predicate()

test/no_exceptions_support_test.cpp

@@ -8,6 +8,12 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4530) // C++ exception handler used
+# pragma warning(disable: 4577) // noexcept used without /EHsc
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/core/quick_exit.hpp>
 #include <boost/throw_exception.hpp>

test/quick_exit_fail.cpp

@@ -1,4 +1,3 @@
-
 // Test for quick_exit.hpp
 //
 // Copyright 2018 Peter Dimov
@@ -7,6 +6,9 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
 
 #include <boost/core/quick_exit.hpp>
 

test/quick_exit_test.cpp

@@ -1,4 +1,3 @@
-
 // Test for quick_exit.hpp
 //
 // Copyright 2018 Peter Dimov
@@ -7,6 +6,9 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
 
 #include <boost/core/quick_exit.hpp>
 

test/ref_conversion_test.cpp

@@ -0,0 +1,39 @@
+//  Implicit conversions between compatible reference wrappers
+//
+//  Copyright 2020 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ref.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct X
+{
+};
+
+struct Y: public X
+{
+};
+
+void f1( boost::reference_wrapper<X> r, Y * p )
+{
+    BOOST_TEST_EQ( r.get_pointer(), p );
+}
+
+void f2( boost::reference_wrapper<int const> r, int * p )
+{
+    BOOST_TEST_EQ( r.get_pointer(), p );
+}
+
+int main()
+{
+    Y y;
+    f1( boost::ref(y), &y );
+
+    int i = 0;
+    f2( boost::ref(i), &i );
+
+    return boost::report_errors();
+}

test/ref_ct_test.cpp

@@ -21,10 +21,16 @@ void ref_test(boost::reference_wrapper<U>)
     BOOST_STATIC_ASSERT((boost::core::is_same<T,type>::value));
 }
 
+template< typename T >
+void assignable_test_(T x1, T x2)
+{
+    x1 = x2;
+}
+
 template< typename T >
 void assignable_test(T x)
 {
-    x = x;
+    assignable_test_( x, x );
 }
 
 template< bool R, typename T >

test/ref_implicit_fail3.cpp

@@ -0,0 +1,29 @@
+//
+// Incompatible reference_wrappers must not implicitly convert to each other
+//
+// Copyright 2020 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+
+#include <boost/ref.hpp>
+
+struct X
+{
+};
+
+struct Y
+{
+};
+
+void f( boost::reference_wrapper<X> )
+{
+}
+
+int main()
+{
+    Y y;
+    f( boost::ref(y) ); // should fail
+}

test/ref_implicit_fail4.cpp

@@ -0,0 +1,21 @@
+//
+// Incompatible reference_wrappers must not implicitly convert to each other
+//
+// Copyright 2020 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+
+#include <boost/ref.hpp>
+
+void f( boost::reference_wrapper< int const > )
+{
+}
+
+int main()
+{
+    long y = 0;
+    f( boost::ref(y) ); // should fail
+}

test/scoped_enum.cpp

@@ -15,6 +15,10 @@
 #include <boost/core/scoped_enum.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4244) // conversion from enum_type to underlying_type
+#endif
+
 BOOST_SCOPED_ENUM_DECLARE_BEGIN(namespace_enum1)
 {
     value0,
@@ -142,6 +146,7 @@ void check_underlying_type()
     // The real check for the type is in the underlying_type trait test.
     namespace_enum2 enum1 = namespace_enum2::value1;
     BOOST_TEST(sizeof(enum1) == sizeof(unsigned char));
+    (void)enum1;
 }
 
 int main(int, char*[])

test/span_constructible_test.cpp

@@ -0,0 +1,200 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#include <boost/core/span.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T>
+struct range {
+    T* data() {
+        return 0;
+    }
+
+    const T* data() const {
+        return 0;
+    }
+
+    std::size_t size() const {
+        return 0;
+    }
+};
+
+struct base { };
+
+struct derived
+    : base { };
+
+void test_default()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<
+        boost::span<int> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<
+        boost::span<int, 0> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<
+        boost::span<int, 2> >));
+}
+
+void test_data_size()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        int*, std::size_t>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        int*, std::size_t>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        int, std::size_t>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        const int*, std::size_t>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
+        derived*, std::size_t>));
+}
+
+void test_first_last()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        int*, int*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        int*, const int*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        int*, int*>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        int, int*>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        const int*, int*>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
+        derived*, derived*>));
+}
+
+void test_array()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        int(&)[4]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int, 4>,
+        int(&)[4]>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 2>,
+        int(&)[4]>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
+        int(&)[2]>));
+}
+
+void test_std_array()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        std::array<int, 4>&>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        std::array<int, 4>&>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int, 4>,
+        std::array<int, 4>&>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int,
+        4>, std::array<int, 4>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        std::array<const int, 4>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
+        std::array<derived, 4>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 2>,
+        std::array<int, 4>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
+        std::array<const int, 4>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base, 4>,
+        std::array<derived, 4>&>));
+}
+
+void test_const_std_array()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        const std::array<int, 4> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int,
+        4>, const std::array<int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        const std::array<int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<const
+        base>, const std::array<derived, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<const int,
+        2>, const std::array<int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
+        const std::array<int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<const
+        base, 4>, const std::array<derived, 4> >));
+}
+
+void test_range()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        range<int>&>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        range<int>&>));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        range<int> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        int*>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        range<int> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        const range<int>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
+        range<derived>&>));
+}
+
+void test_span()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        boost::span<int> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
+        boost::span<int, 4> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int, 4>,
+        boost::span<int> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int,
+        4>, boost::span<int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        boost::span<const int> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
+        boost::span<derived> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 2>,
+        boost::span<int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
+        boost::span<const int, 4> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base, 4>,
+        boost::span<derived, 4> >));
+}
+
+void test_copy()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_copy_constructible<
+        boost::span<int> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_copy_constructible<
+        boost::span<int, 4> >));
+}
+
+void test_assign()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_copy_assignable<
+        boost::span<int> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_copy_assignable<
+        boost::span<int, 4> >));
+}
+
+int main()
+{
+    test_default();
+    test_data_size();
+    test_first_last();
+    test_array();
+    test_std_array();
+    test_const_std_array();
+    test_range();
+    test_span();
+    test_copy();
+    test_assign();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/span_deduction_guide_test.cpp

@@ -0,0 +1,116 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifdef __cpp_deduction_guides
+#include <boost/core/span.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class range {
+public:
+    T* data() {
+        return &v_[0];
+    }
+
+    std::size_t size() const {
+        return 4;
+    }
+
+private:
+    T v_[4];
+};
+
+void test_data_size()
+{
+    int a[4];
+    boost::span s(&a[0], 4);
+    BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_first_last()
+{
+    int a[4];
+    boost::span s(&a[0], &a[4]);
+    BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_array()
+{
+    int a[4];
+    boost::span s(a);
+    BOOST_TEST_EQ(s.extent, 4);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_std_array()
+{
+    std::array<int, 4> a;
+    boost::span s(a);
+    BOOST_TEST_EQ(s.extent, 4);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_const_std_array()
+{
+    const std::array<int, 4> a = std::array<int, 4>();
+    boost::span s(a);
+    BOOST_TEST_EQ(s.extent, 4);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_range()
+{
+    range<int> c;
+    boost::span s(c);
+    BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
+    BOOST_TEST_EQ(s.data(), c.data());
+    BOOST_TEST_EQ(s.size(), c.size());
+}
+
+void test_span_dynamic()
+{
+    int a[4];
+    boost::span s(boost::span<int>(&a[0], 4));
+    BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_span_static()
+{
+    int a[4];
+    boost::span s(boost::span<int, 4>(&a[0], 4));
+    BOOST_TEST_EQ(s.extent, 4);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+int main()
+{
+    test_data_size();
+    test_first_last();
+    test_array();
+    test_std_array();
+    test_const_std_array();
+    test_range();
+    test_span_dynamic();
+    test_span_static();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/span_test.cpp

@@ -0,0 +1,433 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#include <boost/core/span.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class range {
+public:
+    T* data() {
+        return &v_[0];
+    }
+
+    std::size_t size() const {
+        return 4;
+    }
+
+private:
+    T v_[4];
+};
+
+void test_extent()
+{
+    BOOST_TEST_EQ(boost::span<int>::extent,
+        boost::dynamic_extent);
+    BOOST_TEST_EQ((boost::span<int, 2>::extent), 2);
+}
+
+void test_default_construct_dynamic()
+{
+    boost::span<int> s;
+    BOOST_TEST_EQ(s.data(), static_cast<int*>(0));
+    BOOST_TEST_EQ(s.size(), 0);
+}
+
+void test_default_construct_static()
+{
+    boost::span<int, 0> s;
+    BOOST_TEST_EQ(s.data(), static_cast<int*>(0));
+    BOOST_TEST_EQ(s.size(), 0);
+}
+
+void test_construct_data_size()
+{
+    int a[4];
+    boost::span<int> s(&a[0], 4);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_first_last()
+{
+    int a[4];
+    boost::span<int> s(&a[0], &a[4]);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_array_dynamic()
+{
+    int a[4];
+    boost::span<int> s(a);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_array_static()
+{
+    int a[4];
+    boost::span<int, 4> s(a);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_std_array_dynamic()
+{
+    std::array<int, 4> a;
+    boost::span<int> s(a);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_construct_std_array_static()
+{
+    std::array<int, 4> a;
+    boost::span<int, 4> s(a);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_construct_const_std_array_dynamic()
+{
+    const std::array<int, 4> a = std::array<int, 4>();
+    boost::span<const int> s(a);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_construct_const_std_array_static()
+{
+    const std::array<int, 4> a = std::array<int, 4>();
+    boost::span<const int, 4> s(a);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_construct_range()
+{
+    range<int> c;
+    boost::span<int> s(c);
+    BOOST_TEST_EQ(s.data(), c.data());
+    BOOST_TEST_EQ(s.size(), c.size());
+}
+
+void test_construct_span_dynamic()
+{
+    int a[4];
+    boost::span<const int> s(boost::span<int>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_span_dynamic_static()
+{
+    int a[4];
+    boost::span<int> s(boost::span<int, 4>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_span_static()
+{
+    int a[4];
+    boost::span<const int, 4> s(boost::span<int, 4>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_construct_span_static_dynamic()
+{
+    int a[4];
+    boost::span<int, 4> s(boost::span<int>(&a[0], 4));
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_copy_dynamic()
+{
+    int a[4];
+    boost::span<int> s1(&a[0], 4);
+    boost::span<int> s2(s1);
+    BOOST_TEST_EQ(s2.data(), &a[0]);
+    BOOST_TEST_EQ(s2.size(), 4);
+}
+
+void test_copy_static()
+{
+    int a[4];
+    boost::span<int, 4> s1(&a[0], 4);
+    boost::span<int, 4> s2(s1);
+    BOOST_TEST_EQ(s2.data(), &a[0]);
+    BOOST_TEST_EQ(s2.size(), 4);
+}
+
+void test_assign_dynamic()
+{
+    boost::span<int> s;
+    int a[4];
+    s = boost::span<int>(&a[0], 4);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_assign_static()
+{
+    int a1[4];
+    boost::span<int, 4> s(&a1[0], 4);
+    int a2[4];
+    s = boost::span<int, 4>(&a2[0], 4);
+    BOOST_TEST_EQ(s.data(), &a2[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_first()
+{
+    int a[4];
+    boost::span<int, 2> s = boost::span<int>(&a[0],
+        4).first<2>();
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_last()
+{
+    int a[4];
+    boost::span<int, 2> s = boost::span<int>(&a[0], 4).last<2>();
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_subspan_dynamic()
+{
+    int a[4];
+    boost::span<int> s = boost::span<int>(&a[0], 4).subspan<2>();
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_subspan_static()
+{
+    int a[4];
+    boost::span<int, 2> s = boost::span<int, 4>(&a[0],
+        4).subspan<2>();
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_subspan()
+{
+    int a[4];
+    boost::span<int, 1> s = boost::span<int>(&a[0],
+        4).subspan<2, 1>();
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 1);
+}
+
+void test_first_size()
+{
+    int a[4];
+    boost::span<int> s = boost::span<int>(&a[0], 4).first(2);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_last_size()
+{
+    int a[4];
+    boost::span<int> s = boost::span<int>(&a[0], 4).last(2);
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_subspan_range()
+{
+    int a[4];
+    boost::span<int> s = boost::span<int>(&a[0], 4).subspan(2);
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 2);
+}
+
+void test_subspan_range_count()
+{
+    int a[4];
+    boost::span<int> s = boost::span<int>(&a[0],
+        4).subspan(2, 1);
+    BOOST_TEST_EQ(s.data(), &a[2]);
+    BOOST_TEST_EQ(s.size(), 1);
+}
+
+void test_size()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).size()), 4);
+}
+
+void test_size_bytes()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).size_bytes()),
+        4 * sizeof(int));
+}
+
+void test_empty_dynamic()
+{
+    int a[4];
+    BOOST_TEST(boost::span<int>().empty());
+    BOOST_TEST_NOT((boost::span<int>(&a[0], 4).empty()));
+}
+
+void test_empty_static()
+{
+    int a[4];
+    BOOST_TEST((boost::span<int, 0>().empty()));
+    BOOST_TEST_NOT((boost::span<int, 4>(&a[0], 4).empty()));
+}
+
+void test_index()
+{
+    int a[4] = { 1, 2, 3, 4 };
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4)[2]), 3);
+}
+
+void test_front()
+{
+    int a[4] = { 1, 2, 3, 4 };
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).front()), 1);
+}
+
+void test_back()
+{
+    int a[4] = { 1, 2, 3, 4 };
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).back()), 4);
+}
+
+void test_data()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).data()), &a[0]);
+}
+
+void test_begin()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).begin()), &a[0]);
+}
+
+void test_end()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).end()), &a[4]);
+}
+
+void test_rbegin()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).rbegin().base()), &a[4]);
+}
+
+void test_rend()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).rend().base()), &a[0]);
+}
+
+void test_cbegin()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).cbegin()), &a[0]);
+}
+
+void test_cend()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).cend()), &a[4]);
+}
+
+void test_crbegin()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).crbegin().base()), &a[4]);
+}
+
+void test_crend()
+{
+    int a[4];
+    BOOST_TEST_EQ((boost::span<int>(&a[0], 4).crend().base()), &a[0]);
+}
+
+void test_begin_span()
+{
+    int a[4];
+    BOOST_TEST_EQ((begin(boost::span<int>(&a[0], 4))), &a[0]);
+}
+
+void test_end_span()
+{
+    int a[4];
+    BOOST_TEST_EQ((end(boost::span<int>(&a[0], 4))), &a[4]);
+}
+
+int main()
+{
+    test_extent();
+    test_default_construct_dynamic();
+    test_default_construct_static();
+    test_construct_data_size();
+    test_construct_first_last();
+    test_construct_array_dynamic();
+    test_construct_array_static();
+    test_construct_std_array_dynamic();
+    test_construct_std_array_static();
+    test_construct_const_std_array_dynamic();
+    test_construct_const_std_array_static();
+    test_construct_range();
+    test_construct_span_dynamic();
+    test_construct_span_dynamic_static();
+    test_construct_span_static();
+    test_construct_span_static_dynamic();
+    test_copy_dynamic();
+    test_copy_static();
+    test_assign_dynamic();
+    test_assign_static();
+    test_first();
+    test_last();
+    test_subspan_dynamic();
+    test_subspan_static();
+    test_subspan();
+    test_first_size();
+    test_last_size();
+    test_subspan_range();
+    test_subspan_range_count();
+    test_size();
+    test_size_bytes();
+    test_empty_dynamic();
+    test_empty_static();
+    test_index();
+    test_front();
+    test_back();
+    test_data();
+    test_begin();
+    test_end();
+    test_rbegin();
+    test_rend();
+    test_cbegin();
+    test_cend();
+    test_crbegin();
+    test_crend();
+    test_begin_span();
+    test_end_span();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/span_types_test.cpp

@@ -0,0 +1,136 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#include <boost/core/span.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+void test_element_type()
+{
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::span<int>::element_type);
+    BOOST_TEST_TRAIT_SAME(char,
+        boost::span<char>::element_type);
+}
+
+void test_value_type()
+{
+    BOOST_TEST_TRAIT_SAME(char,
+        boost::span<char>::value_type);
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::span<int>::value_type);
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::span<const int>::value_type);
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::span<volatile int>::value_type);
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::span<const volatile int>::value_type);
+}
+
+void test_size_type()
+{
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::span<char>::size_type);
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::span<int>::size_type);
+}
+
+void test_difference_type()
+{
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::span<char>::difference_type);
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::span<int>::difference_type);
+}
+
+void test_pointer()
+{
+    BOOST_TEST_TRAIT_SAME(char*,
+        boost::span<char>::pointer);
+    BOOST_TEST_TRAIT_SAME(int*,
+        boost::span<int>::pointer);
+}
+
+void test_const_pointer()
+{
+    BOOST_TEST_TRAIT_SAME(const char*,
+        boost::span<char>::const_pointer);
+    BOOST_TEST_TRAIT_SAME(const int*,
+        boost::span<int>::const_pointer);
+}
+
+void test_reference()
+{
+    BOOST_TEST_TRAIT_SAME(char&,
+        boost::span<char>::reference);
+    BOOST_TEST_TRAIT_SAME(int&,
+        boost::span<int>::reference);
+}
+
+void test_const_reference()
+{
+    BOOST_TEST_TRAIT_SAME(const char&,
+        boost::span<char>::const_reference);
+    BOOST_TEST_TRAIT_SAME(const int&,
+        boost::span<int>::const_reference);
+}
+
+void test_iterator()
+{
+    BOOST_TEST_TRAIT_SAME(char*,
+        boost::span<char>::iterator);
+    BOOST_TEST_TRAIT_SAME(int*,
+        boost::span<int>::iterator);
+}
+
+void test_const_iterator()
+{
+    BOOST_TEST_TRAIT_SAME(const char*,
+        boost::span<char>::const_iterator);
+    BOOST_TEST_TRAIT_SAME(const int*,
+        boost::span<int>::const_iterator);
+}
+
+void test_reverse_iterator()
+{
+    BOOST_TEST_TRAIT_SAME(std::reverse_iterator<char*>,
+        boost::span<char>::reverse_iterator);
+    BOOST_TEST_TRAIT_SAME(std::reverse_iterator<int*>,
+        boost::span<int>::reverse_iterator);
+}
+
+void test_const_reverse_iterator()
+{
+    BOOST_TEST_TRAIT_SAME(std::reverse_iterator<const char*>,
+        boost::span<char>::const_reverse_iterator);
+    BOOST_TEST_TRAIT_SAME(std::reverse_iterator<const int*>,
+        boost::span<int>::const_reverse_iterator);
+}
+
+int main()
+{
+    test_element_type();
+    test_value_type();
+    test_size_type();
+    test_difference_type();
+    test_pointer();
+    test_const_pointer();
+    test_reference();
+    test_const_reference();
+    test_iterator();
+    test_const_iterator();
+    test_reverse_iterator();
+    test_const_reverse_iterator();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/sv_compare_test.cpp

@@ -0,0 +1,145 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv1( "" );
+        boost::core::string_view sv2( "" );
+
+        BOOST_TEST_EQ( sv1.compare( sv2 ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 0, sv2 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 1, sv2 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 1, 0, sv2 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 1, 1, sv2 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 1, npos, sv2 ), std::out_of_range );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 0, sv2, 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 1, sv2, 0, 1 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 1, 0, sv2, 0, 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 1, 1, sv2, 0, 1 ), std::out_of_range );
+
+        BOOST_TEST_THROWS( sv1.compare( 0, 0, sv2, 1, 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 0, 1, sv2, 1, 1 ), std::out_of_range );
+
+        BOOST_TEST_EQ( sv1.compare( "" ), 0 );
+        BOOST_TEST_LT( sv1.compare( "1" ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 0, "" ), 0 );
+        BOOST_TEST_LT( sv1.compare( 0, 0, "1" ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 1, "" ), 0 );
+        BOOST_TEST_LT( sv1.compare( 0, 1, "1" ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 1, 0, "" ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 1, 1, "1" ), std::out_of_range );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 0, "", 0 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 0, "1", 0 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 0, 0, "1", 1 ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 1, "", 0 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 1, "1", 0 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 0, 1, "1", 1 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 1, 0, "", 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 1, 1, "1", 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 1, 1, "1", 1 ), std::out_of_range );
+    }
+
+    {
+        boost::core::string_view sv1( "123412345" );
+        boost::core::string_view sv2( "1234" );
+
+        BOOST_TEST_GT( sv1.compare( sv2 ), 0 );
+
+        BOOST_TEST_LT( sv1.compare( 0, 3, sv2 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 4, sv2 ), 0 );
+        BOOST_TEST_GT( sv1.compare( 0, 5, sv2 ), 0 );
+        BOOST_TEST_GT( sv1.compare( 0, npos, sv2 ), 0 );
+
+        BOOST_TEST_LT( sv1.compare( 1, 0, sv2 ), 0 );
+        BOOST_TEST_GT( sv1.compare( 1, 1, sv2 ), 0 );
+
+        BOOST_TEST_LT( sv1.compare( 4, 3, sv2 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 4, 4, sv2 ), 0 );
+        BOOST_TEST_GT( sv1.compare( 4, 5, sv2 ), 0 );
+
+        BOOST_TEST_LT( sv1.compare( 9, 0, sv2 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 9, 1, sv2 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 10, 0, sv2 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 10, 1, sv2 ), std::out_of_range );
+
+        BOOST_TEST_GT( sv1.compare( 0, 3, sv2, 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 3, sv2, 0, 3 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 0, 3, sv2, 0, 4 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 0, 3, sv2, 0, 5 ), 0 );
+
+        BOOST_TEST_GT( sv1.compare( 0, 4, sv2, 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 4, sv2, 0, 4 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 0, 4, sv2, 0, 5 ), 0 );
+
+        BOOST_TEST_LT( sv1.compare( 5, 2, sv2, 1, npos ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 5, 3, sv2, 1, npos ), 0 );
+        BOOST_TEST_GT( sv1.compare( 5, 4, sv2, 1, npos ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 9, 0, sv2, 0, 0 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 9, 1, sv2, 0, 1 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 10, 0, sv2, 0, 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 10, 1, sv2, 0, 1 ), std::out_of_range );
+
+        BOOST_TEST_EQ( sv1.compare( 0, 0, sv2, 4, 0 ), 0 );
+        BOOST_TEST_GT( sv1.compare( 0, 1, sv2, 4, 1 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 0, 0, sv2, 5, 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 0, 1, sv2, 5, 1 ), std::out_of_range );
+
+        BOOST_TEST_GT( sv1.compare( "" ), 0 );
+        BOOST_TEST_GT( sv1.compare( "12341234" ), 0 );
+        BOOST_TEST_GT( sv1.compare( "123412344" ), 0 );
+        BOOST_TEST_EQ( sv1.compare( "123412345" ), 0 );
+        BOOST_TEST_LT( sv1.compare( "123412346" ), 0 );
+        BOOST_TEST_LT( sv1.compare( "1234123456" ), 0 );
+
+        BOOST_TEST_GT( sv1.compare( 4, 3, "" ), 0 );
+        BOOST_TEST_GT( sv1.compare( 4, 3, "1" ), 0 );
+        BOOST_TEST_GT( sv1.compare( 4, 3, "12" ), 0 );
+        BOOST_TEST_GT( sv1.compare( 4, 3, "122" ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 4, 3, "123" ), 0 );
+        BOOST_TEST_LT( sv1.compare( 4, 3, "124" ), 0 );
+        BOOST_TEST_LT( sv1.compare( 4, 3, "1234" ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 9, 0, "" ), 0 );
+        BOOST_TEST_LT( sv1.compare( 9, 1, "1" ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 10, 0, "" ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 10, 1, "1" ), std::out_of_range );
+
+        BOOST_TEST_GT( sv1.compare( 4, npos, "123456", 4 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 4, npos, "123456", 5 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 4, npos, "123456", 6 ), 0 );
+
+        BOOST_TEST_EQ( sv1.compare( 9, npos, "", 0 ), 0 );
+        BOOST_TEST_EQ( sv1.compare( 9, npos, "1", 0 ), 0 );
+        BOOST_TEST_LT( sv1.compare( 9, npos, "1", 1 ), 0 );
+
+        BOOST_TEST_THROWS( sv1.compare( 10, npos, "", 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 10, npos, "1", 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv1.compare( 10, npos, "1", 1 ), std::out_of_range );
+    }
+
+    return boost::report_errors();
+}

test/sv_construct_test.cpp

@@ -0,0 +1,346 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <iterator>
+#include <string>
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# include <memory_resource>
+#endif
+
+template<class It> std::reverse_iterator<It> make_reverse_iterator( It it )
+{
+    return std::reverse_iterator<It>( it );
+}
+
+int main()
+{
+    {
+        boost::core::string_view sv;
+
+        BOOST_TEST_EQ( sv.data(), static_cast<char const*>(0) );
+        BOOST_TEST_EQ( sv.size(), 0 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+    }
+
+    {
+        char const* s = "";
+
+        boost::core::string_view sv( s );
+
+        BOOST_TEST_EQ( sv.data(), s );
+        BOOST_TEST_EQ( sv.size(), 0 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+    {
+        char const* s = "123";
+
+        boost::core::string_view sv( s );
+
+        BOOST_TEST_EQ( sv.data(), s );
+        BOOST_TEST_EQ( sv.size(), 3 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+    {
+        char const* s = "123";
+
+        boost::core::string_view sv( s, 0 );
+
+        BOOST_TEST_EQ( sv.data(), s );
+        BOOST_TEST_EQ( sv.size(), 0 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+    {
+        char const* s = "123";
+
+        boost::core::string_view sv( s, 2 );
+
+        BOOST_TEST_EQ( sv.data(), s );
+        BOOST_TEST_EQ( sv.size(), 2 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+    {
+        char const* s = "123";
+
+        boost::core::string_view sv( s, s );
+
+        BOOST_TEST_EQ( sv.data(), s );
+        BOOST_TEST_EQ( sv.size(), 0 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+    {
+        char const* s = "123";
+
+        boost::core::string_view sv( s, s + 2 );
+
+        BOOST_TEST_EQ( sv.data(), s );
+        BOOST_TEST_EQ( sv.size(), 2 );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+    {
+        std::string str = "123";
+
+        boost::core::string_view sv( str );
+
+        BOOST_TEST_EQ( sv.data(), str.data() );
+        BOOST_TEST_EQ( sv.size(), str.size() );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+    {
+        std::string_view str = "123";
+
+        boost::core::string_view sv( str );
+
+        BOOST_TEST_EQ( sv.data(), str.data() );
+        BOOST_TEST_EQ( sv.size(), str.size() );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+#endif
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+
+    {
+        using pmr_string = std::basic_string<char, std::char_traits<char>, std::pmr::polymorphic_allocator<char>>;
+
+        pmr_string str = "123";
+
+        boost::core::string_view sv( str );
+
+        BOOST_TEST_EQ( sv.data(), str.data() );
+        BOOST_TEST_EQ( sv.size(), str.size() );
+
+        BOOST_TEST_EQ( sv.begin(), sv.data() );
+        BOOST_TEST_EQ( sv.end(), sv.data() + sv.size() );
+
+        BOOST_TEST_EQ( sv.cbegin(), sv.data() );
+        BOOST_TEST_EQ( sv.cend(), sv.data() + sv.size() );
+
+        BOOST_TEST( sv.rbegin() == ::make_reverse_iterator( sv.end() ) );
+        BOOST_TEST( sv.rend() == ::make_reverse_iterator( sv.begin() ) );
+
+        BOOST_TEST( sv.crbegin() == ::make_reverse_iterator( sv.cend() ) );
+        BOOST_TEST( sv.crend() == ::make_reverse_iterator( sv.cbegin() ) );
+
+        BOOST_TEST_EQ( sv.length(), sv.size() );
+        BOOST_TEST_EQ( sv.empty(), sv.size() == 0 );
+
+        BOOST_TEST_EQ( sv.max_size(), boost::core::string_view::npos );
+
+        if( !sv.empty() )
+        {
+            BOOST_TEST_EQ( &sv.front(), sv.data() );
+            BOOST_TEST_EQ( &sv.back(), sv.data() + sv.size() - 1 );
+        }
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/sv_contains_test.cpp

@@ -0,0 +1,71 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cstddef>
+
+int main()
+{
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST( sv.contains( boost::core::string_view() ) );
+
+        BOOST_TEST( sv.contains( boost::core::string_view( "" ) ) );
+        BOOST_TEST( !sv.contains( boost::core::string_view( "1" ) ) );
+
+        BOOST_TEST( !sv.contains( '1' ) );
+
+        BOOST_TEST( sv.contains( "" ) );
+        BOOST_TEST( !sv.contains( "1" ) );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST( sv.contains( boost::core::string_view() ) );
+        BOOST_TEST( sv.contains( boost::core::string_view( "" ) ) );
+
+        BOOST_TEST( sv.contains( boost::core::string_view( "1" ) ) );
+        BOOST_TEST( sv.contains( boost::core::string_view( "2" ) ) );
+        BOOST_TEST( sv.contains( boost::core::string_view( "3" ) ) );
+        BOOST_TEST( !sv.contains( boost::core::string_view( "4" ) ) );
+
+        BOOST_TEST( sv.contains( boost::core::string_view( "12" ) ) );
+        BOOST_TEST( sv.contains( boost::core::string_view( "23" ) ) );
+        BOOST_TEST( !sv.contains( boost::core::string_view( "34" ) ) );
+        BOOST_TEST( !sv.contains( boost::core::string_view( "21" ) ) );
+
+        BOOST_TEST( sv.contains( '1' ) );
+        BOOST_TEST( sv.contains( '2' ) );
+        BOOST_TEST( sv.contains( '3' ) );
+        BOOST_TEST( !sv.contains( '4' ) );
+
+        BOOST_TEST( sv.contains( "" ) );
+
+        BOOST_TEST( sv.contains( "1" ) );
+        BOOST_TEST( sv.contains( "2" ) );
+        BOOST_TEST( sv.contains( "3" ) );
+        BOOST_TEST( !sv.contains( "4" ) );
+
+        BOOST_TEST( sv.contains( "12" ) );
+        BOOST_TEST( sv.contains( "23" ) );
+        BOOST_TEST( !sv.contains( "34" ) );
+        BOOST_TEST( !sv.contains( "21" ) );
+
+        BOOST_TEST( sv.contains( "123" ) );
+        BOOST_TEST( !sv.contains( "234" ) );
+        BOOST_TEST( sv.contains( "231" ) );
+        BOOST_TEST( !sv.contains( "321" ) );
+
+        BOOST_TEST( !sv.contains( "1234" ) );
+        BOOST_TEST( sv.contains( "1231" ) );
+
+        BOOST_TEST( sv.contains( "123123" ) );
+        BOOST_TEST( !sv.contains( "1231231" ) );
+    }
+
+    return boost::report_errors();
+}

test/sv_conversion_test.cpp

@@ -0,0 +1,54 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# include <memory_resource>
+#endif
+
+boost::core::string_view f( boost::core::string_view const& str )
+{
+    return str;
+}
+
+int main()
+{
+    {
+        std::string s1( "123" );
+        std::string s2 = f( s1 );
+
+        BOOST_TEST_EQ( s1, s2 );
+    }
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+    {
+        std::string_view s1( "123" );
+        std::string_view s2 = f( s1 );
+
+        BOOST_TEST_EQ( s1, s2 );
+    }
+
+#endif
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+
+    {
+        using pmr_string = std::basic_string<char, std::char_traits<char>, std::pmr::polymorphic_allocator<char>>;
+
+        pmr_string s1( "123" );
+        pmr_string s2 = f( s1 );
+
+        BOOST_TEST_EQ( s1, s2 );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/sv_copy_test.cpp

@@ -0,0 +1,52 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#define _SCL_SECURE_NO_WARNINGS
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+#include <cstddef>
+
+int main()
+{
+    {
+        boost::core::string_view sv;
+
+        BOOST_TEST_EQ( sv.copy( 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.copy( 0, 0, 0 ), 0 );
+        BOOST_TEST_THROWS( sv.copy( 0, 0, 1 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.copy( 0, 0, boost::core::string_view::npos ), std::out_of_range );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+        char buffer[ 8 ] = {};
+
+        BOOST_TEST_EQ( sv.copy( buffer, 0 ), 0 );
+        BOOST_TEST_EQ( buffer[0], 0 );
+
+        BOOST_TEST_EQ( sv.copy( buffer, 0, 0 ), 0 );
+        BOOST_TEST_EQ( buffer[0], 0 );
+
+        BOOST_TEST_EQ( sv.copy( buffer, 0, 1 ), 0 );
+        BOOST_TEST_EQ( buffer[0], 0 );
+
+        BOOST_TEST_THROWS( sv.copy( buffer, 0, boost::core::string_view::npos ), std::out_of_range );
+        BOOST_TEST_EQ( buffer[0], 0 );
+
+        BOOST_TEST_EQ( sv.copy( buffer, 1 ), 1 );
+        BOOST_TEST_EQ( buffer[0], '1' );
+        BOOST_TEST_EQ( buffer[1], 0 );
+
+        BOOST_TEST_EQ( sv.copy( buffer, 1, 1 ), 1 );
+        BOOST_TEST_EQ( buffer[0], '2' );
+        BOOST_TEST_EQ( buffer[1], 0 );
+
+        BOOST_TEST_EQ( sv.copy( buffer, 8 ), 5 );
+        BOOST_TEST_CSTR_EQ( buffer, "12345" );
+    }
+
+    return boost::report_errors();
+}

test/sv_element_access_test.cpp

@@ -0,0 +1,41 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+
+int main()
+{
+    {
+        boost::core::string_view sv( "12345" );
+
+        for( std::size_t i = 0; i < 5; ++i )
+        {
+            BOOST_TEST_EQ( &sv[ i ], sv.data() + i );
+            BOOST_TEST_EQ( &sv.at( i ), sv.data() + i );
+        }
+
+        BOOST_TEST_THROWS( sv.at( 5 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.at( boost::core::string_view::npos ), std::out_of_range );
+    }
+
+    {
+        boost::core::string_view sv;
+
+        BOOST_TEST_THROWS( sv.at( 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.at( 1 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.at( boost::core::string_view::npos ), std::out_of_range );
+    }
+
+    {
+        boost::core::string_view sv( "12345", 0 );
+
+        BOOST_TEST_THROWS( sv.at( 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.at( 1 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.at( boost::core::string_view::npos ), std::out_of_range );
+    }
+
+    return boost::report_errors();
+}

test/sv_ends_with_test.cpp

@@ -0,0 +1,50 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+#include <cstddef>
+
+int main()
+{
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST( sv.ends_with( boost::core::string_view() ) );
+        BOOST_TEST( sv.ends_with( boost::core::string_view( "" ) ) );
+        BOOST_TEST( sv.ends_with( "" ) );
+
+        BOOST_TEST( !sv.ends_with( boost::core::string_view( "1" ) ) );
+        BOOST_TEST( !sv.ends_with( '1' ) );
+        BOOST_TEST( !sv.ends_with( "1" ) );
+    }
+
+    {
+        boost::core::string_view sv( "123" );
+
+        BOOST_TEST( sv.ends_with( boost::core::string_view() ) );
+        BOOST_TEST( sv.ends_with( boost::core::string_view( "" ) ) );
+        BOOST_TEST( sv.ends_with( "" ) );
+
+        BOOST_TEST( sv.ends_with( boost::core::string_view( "3" ) ) );
+        BOOST_TEST( sv.ends_with( '3' ) );
+        BOOST_TEST( sv.ends_with( "3" ) );
+
+        BOOST_TEST( sv.ends_with( boost::core::string_view( "23" ) ) );
+        BOOST_TEST( sv.ends_with( "23" ) );
+
+        BOOST_TEST( sv.ends_with( boost::core::string_view( "123" ) ) );
+        BOOST_TEST( sv.ends_with( "123" ) );
+
+        BOOST_TEST( !sv.ends_with( boost::core::string_view( "1234" ) ) );
+        BOOST_TEST( !sv.ends_with( "1234" ) );
+
+        BOOST_TEST( !sv.ends_with( boost::core::string_view( "2" ) ) );
+        BOOST_TEST( !sv.ends_with( '2' ) );
+        BOOST_TEST( !sv.ends_with( "2" ) );
+    }
+
+    return boost::report_errors();
+}

test/sv_eq_test.cpp

@@ -0,0 +1,113 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cstddef>
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# include <memory_resource>
+#endif
+
+#define TEST_EQ(x, y) \
+    BOOST_TEST_EQ(x, y); \
+    BOOST_TEST_NOT((x) != (y)); \
+    BOOST_TEST_LE(x, y); \
+    BOOST_TEST_GE(x, y); \
+    BOOST_TEST_NOT((x) < (y)); \
+    BOOST_TEST_NOT((x) > (y))
+
+#define TEST_NE(x, y) \
+    BOOST_TEST_NE(x, y); \
+    BOOST_TEST_NOT((x) == (y)); \
+    BOOST_TEST((x) < (y) || (x) > (y));
+
+int main()
+{
+    {
+        boost::core::string_view sv1( "" );
+        boost::core::string_view sv2( "" );
+        boost::core::string_view sv3( "123" );
+        boost::core::string_view sv4( "123" );
+        boost::core::string_view sv5( "12345" );
+        boost::core::string_view sv6( "12345" );
+
+        TEST_EQ( sv1, sv1 );
+        TEST_EQ( sv1, sv2 );
+        TEST_NE( sv1, sv3 );
+        TEST_NE( sv1, sv5 );
+
+        TEST_EQ( sv3, sv3 );
+        TEST_EQ( sv3, sv4 );
+        TEST_NE( sv3, sv1 );
+        TEST_NE( sv3, sv5 );
+
+        TEST_EQ( sv5, sv5 );
+        TEST_EQ( sv5, sv6 );
+        TEST_NE( sv5, sv1 );
+        TEST_NE( sv5, sv3 );
+
+        BOOST_TEST_EQ( sv1, std::string( "" ) );
+        BOOST_TEST_EQ( std::string( "" ), sv1 );
+
+        BOOST_TEST_NE( sv1, std::string( "1" ) );
+        BOOST_TEST_NE( std::string( "1" ), sv1 );
+
+        BOOST_TEST_EQ( sv3, std::string( "123" ) );
+        BOOST_TEST_EQ( std::string( "123" ), sv3 );
+
+        BOOST_TEST_NE( sv3, std::string( "122" ) );
+        BOOST_TEST_NE( std::string( "122" ), sv3 );
+
+        BOOST_TEST_EQ( sv1, "" );
+        BOOST_TEST_EQ( "", sv1 );
+
+        BOOST_TEST_NE( sv1, "1" );
+        BOOST_TEST_NE( "1", sv1 );
+
+        BOOST_TEST_EQ( sv3, "123" );
+        BOOST_TEST_EQ( "123", sv3 );
+
+        BOOST_TEST_NE( sv3, "122" );
+        BOOST_TEST_NE( "122", sv3 );
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+        BOOST_TEST_EQ( sv1, std::string_view( "" ) );
+        BOOST_TEST_EQ( std::string_view( "" ), sv1 );
+
+        BOOST_TEST_NE( sv1, std::string_view( "1" ) );
+        BOOST_TEST_NE( std::string_view( "1" ), sv1 );
+
+        BOOST_TEST_EQ( sv3, std::string_view( "123" ) );
+        BOOST_TEST_EQ( std::string_view( "123" ), sv3 );
+
+        BOOST_TEST_NE( sv3, std::string_view( "122" ) );
+        BOOST_TEST_NE( std::string_view( "122" ), sv3 );
+
+#endif
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+
+        using pmr_string = std::basic_string<char, std::char_traits<char>, std::pmr::polymorphic_allocator<char>>;
+
+        BOOST_TEST_EQ( sv1, pmr_string( "" ) );
+        BOOST_TEST_EQ( pmr_string( "" ), sv1 );
+
+        BOOST_TEST_NE( sv1, pmr_string( "1" ) );
+        BOOST_TEST_NE( pmr_string( "1" ), sv1 );
+
+        BOOST_TEST_EQ( sv3, pmr_string( "123" ) );
+        BOOST_TEST_EQ( pmr_string( "123" ), sv3 );
+
+        BOOST_TEST_NE( sv3, pmr_string( "122" ) );
+        BOOST_TEST_NE( pmr_string( "122" ), sv3 );
+
+#endif
+    }
+
+    return boost::report_errors();
+}

test/sv_find_first_not_of_test.cpp

@@ -0,0 +1,648 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <algorithm>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view() ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( '1' ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "" ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "1" ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view() ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1' ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"" ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1" ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view() ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view(), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ) ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "1" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "4" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::string_view( "23" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( '1' ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( '1', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( '3' ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( '3', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( '9' ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( '9', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "1" ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "23" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 2, 0 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 3, 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 4, 0 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 0, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 1, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 2, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 3, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 4, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 5, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 0, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 1, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 2, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 3, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 4, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 5, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 6, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 7, 2 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 0, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 1, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 2, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 3, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 5, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( "123", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123123" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view() ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view(), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ) ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"1" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"4" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( boost::core::wstring_view( L"23" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1' ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'1', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3' ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'3', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9' ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L'9', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1" ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 2, 0 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 3, 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 4, 0 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 0, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 1, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 2, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 3, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 4, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 5, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 0, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 1, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 2, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 3, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 4, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 5, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 6, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 7, 2 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 0, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 1, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 2, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 3, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 5, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"123", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"\x101\x102\x103\x101\x102\x103" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 2, 0 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 3, 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 4, 0 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 0, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 1, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 2, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 3, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 4, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 5, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 0, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 1, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 2, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 3, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 4, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 5, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 6, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 7, 2 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 0, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 1, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 2, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 3, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 5, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"\x101\x102\x103", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "0123456789", 12 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"0123456789", 12 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), npos );
+    }
+
+    {
+        char str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< unsigned char >( i );
+        }
+
+        boost::core::string_view sv( str, 256 );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( sv ), npos );
+
+        std::string str2( sv.data(), sv.size() );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_first_not_of( str3 ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_first_not_of( str3 ), 255 - i );
+        }
+    }
+
+    {
+        wchar_t str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< wchar_t >( 0x100 + i );
+        }
+
+        boost::core::wstring_view sv( str, 256 );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( sv ), npos );
+
+        std::wstring str2( sv.data(), sv.size() );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_first_not_of( str3 ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_first_not_of( str3 ), 255 - i );
+        }
+    }
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    {
+        boost::core::u8string_view sv( u8"123123" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1" ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"123", 7 ), npos );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"0123456789", 12 ), npos );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), npos );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/sv_find_first_of_test.cpp

@@ -0,0 +1,553 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <algorithm>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view() ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( '1' ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "1" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"" );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view() ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L'1' ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"1" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view() ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view(), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view(), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view(), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "1" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "4" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "4" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "4" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "4" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ) ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::string_view( "23" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( '1' ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( '1', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( '3' ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 4 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( '3', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( '9' ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "1" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "23" ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "123", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 1, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 2, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 3, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 4, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 5, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "123", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 1, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 2, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 4, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 5, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "123", 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 1, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 2, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 3, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 4, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 5, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 6, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 7, 2 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( "123", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 1, 3 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 2, 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 4, 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 5, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( "123", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123123" );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view() ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view(), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view(), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view(), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ) ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"1" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"4" ) ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"4" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"4" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"4" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ) ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( boost::core::wstring_view( L"23" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L'1' ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L'1', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L'3' ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 4 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L'3', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L'9' ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"1" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"23" ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 1, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 2, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 3, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 4, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 5, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 1, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 2, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 4, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 5, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 1, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 2, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 3, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 4, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 5, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 6, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 7, 2 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 1, 3 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 2, 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 4, 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 5, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"123", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"\x101\x102\x103\x101\x102\x103" );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 1, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 2, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 3, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 4, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 5, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 1, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 2, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 4, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 5, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 1, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 2, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 3, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 4, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 5, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 6, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 7, 2 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 1, 3 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 2, 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 4, 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 5, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( L"\x101\x102\x103", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "0123456789", 12 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"0123456789", 12 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), npos );
+    }
+
+    {
+        char str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< unsigned char >( i );
+        }
+
+        boost::core::string_view sv( str, 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string needle( 12, static_cast< unsigned char >( i ) );
+            BOOST_TEST_EQ( sv.find_first_of( needle ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string needle( 12, static_cast< unsigned char >( i ) );
+            BOOST_TEST_EQ( sv.find_first_of( needle ), 255 - i );
+        }
+    }
+
+    {
+        wchar_t str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< wchar_t >( 0x100 + i );
+        }
+
+        boost::core::wstring_view sv( str, 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring needle( 12, static_cast< wchar_t >( 0x100 + i ) );
+            BOOST_TEST_EQ( sv.find_first_of( needle ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring needle( 12, static_cast< wchar_t >( 0x100 + i ) );
+            BOOST_TEST_EQ( sv.find_first_of( needle ), 255 - i );
+        }
+    }
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    {
+        boost::core::u8string_view sv( u8"123123" );
+
+        BOOST_TEST_EQ( sv.find_first_of( u8"" ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( u8"1" ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( u8"23" ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_first_of( u8"123", 7 ), npos );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"0123456789", 12 ), npos );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_first_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), npos );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/sv_find_last_not_of_test.cpp

@@ -0,0 +1,648 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <algorithm>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view() ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( '1' ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "" ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "1" ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view() ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1' ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"" ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1" ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view(), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view() ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "1" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "4" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ), 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::string_view( "23" ) ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1', 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '1' ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 5 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 6 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3', 7 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '3' ), 4 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9', 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( '9' ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "1" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23", 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "23" ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 2, 0 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 3, 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 4, 0 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 6, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 7, 0 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 1, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 2, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 3, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 4, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 5, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 6, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 7, 1 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 1, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 2, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 3, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 4, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 5, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 6, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 7, 2 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 0, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 1, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 2, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 3, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 5, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "123", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123123" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view(), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view() ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"1" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"4" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ), 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( boost::core::wstring_view( L"23" ) ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1', 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'1' ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 5 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 6 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3', 7 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'3' ), 4 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9', 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L'9' ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"1" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23", 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"23" ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 2, 0 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 3, 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 4, 0 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 6, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 7, 0 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 1, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 2, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 3, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 4, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 5, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 6, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 7, 1 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 1, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 2, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 3, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 4, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 5, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 6, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 7, 2 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 0, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 1, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 2, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 3, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 5, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"123", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"\x101\x102\x103\x101\x102\x103" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 2, 0 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 3, 0 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 4, 0 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 6, 0 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 7, 0 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 1, 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 2, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 3, 1 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 4, 1 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 5, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 6, 1 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 7, 1 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 1, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 2, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 3, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 4, 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 5, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 6, 2 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 7, 2 ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 0, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 1, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 2, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 3, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 5, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"\x101\x102\x103", 7, 3 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "0123456789" ), 11 );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"0123456789" ), 11 );
+    }
+
+    {
+        boost::core::string_view sv( "abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 11 );
+    }
+
+    {
+        boost::core::wstring_view sv( L"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 11 );
+    }
+
+    {
+        char str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< unsigned char >( i );
+        }
+
+        boost::core::string_view sv( str, 256 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( sv ), npos );
+
+        std::string str2( sv.data(), sv.size() );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_last_not_of( str3 ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_last_not_of( str3 ), 255 - i );
+        }
+    }
+
+    {
+        wchar_t str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< wchar_t >( 0x100 + i );
+        }
+
+        boost::core::wstring_view sv( str, 256 );
+
+        BOOST_TEST_EQ( sv.find_first_not_of( sv ), npos );
+
+        std::wstring str2( sv.data(), sv.size() );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_first_not_of( str3 ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring str3( str2 );
+
+            str3[ i ] = ~str3[ i ];
+
+            BOOST_TEST_EQ( sv.find_first_not_of( str3 ), 255 - i );
+        }
+    }
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    {
+        boost::core::u8string_view sv( u8"123123" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"1" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23", 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"23" ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 3 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 4 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 5 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"123", 7 ), npos );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"0123456789" ), 11 );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_not_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 11 );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/sv_find_last_of_test.cpp

@@ -0,0 +1,575 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <algorithm>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view() ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( '1' ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "" ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "1" ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::wstring_view sv( L"" );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view() ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L'1' ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"" ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"1" ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"12", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"12", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"12", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"12", 1, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"12", 0, 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"12", 1, 2 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view(), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view(), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view(), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view(), 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view() ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ), 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "1" ) ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "4" ), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "4" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "4" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "4" ), 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "4" ) ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::string_view( "23" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( '1', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( '1', 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( '1' ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( '3', 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 4 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( '3', 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( '3' ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( '9' ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "", 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "" ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "1", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "1", 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "1" ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( "23", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( "23", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( "23" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( "123", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 1, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 2, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 3, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 4, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 5, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( "123", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 1, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 2, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 4, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 5, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 6, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 7, 1 ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( "123", 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 1, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 2, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 3, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 4, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 5, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 6, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 7, 2 ), 4 );
+
+        BOOST_TEST_EQ( sv.find_last_of( "123", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 1, 3 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 2, 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 4, 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 5, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 6, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( "123", 7, 3 ), 5 );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123123" );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view(), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view(), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view(), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view(), 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view() ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"" ) ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ), 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"1" ) ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"4" ), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"4" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"4" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"4" ), 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"4" ) ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ), 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( boost::core::wstring_view( L"23" ) ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1', 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L'1' ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 4 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L'3', 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L'3' ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L'9' ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"", 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"" ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1", 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"1" ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"23" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 1, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 2, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 3, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 4, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 5, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 1, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 2, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 4, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 5, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 6, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 7, 1 ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 1, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 2, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 3, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 4, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 5, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 6, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 7, 2 ), 4 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 1, 3 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 2, 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 4, 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 5, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 6, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"123", 7, 3 ), 5 );
+    }
+
+    {
+        boost::core::wstring_view sv( L"\x101\x102\x103\x101\x102\x103" );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 0, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 1, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 2, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 3, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 4, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 5, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 6, 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 1, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 2, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 4, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 5, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 6, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 7, 1 ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 0, 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 1, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 2, 2 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 3, 2 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 4, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 5, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 6, 2 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 7, 2 ), 4 );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 1, 3 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 2, 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 4, 3 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 5, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 6, 3 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( L"\x101\x102\x103", 7, 3 ), 5 );
+    }
+
+    {
+        boost::core::string_view sv( "abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( "0123456789" ), 11 );
+    }
+
+    {
+        boost::core::wstring_view sv( L"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( L"0123456789" ), 11 );
+    }
+
+    {
+        boost::core::string_view sv( "123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 11 );
+    }
+
+    {
+        boost::core::wstring_view sv( L"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 11 );
+    }
+
+    {
+        char str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< unsigned char >( i );
+        }
+
+        boost::core::string_view sv( str, 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string needle( 12, static_cast< unsigned char >( i ) );
+            BOOST_TEST_EQ( sv.find_last_of( needle ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::string needle( 12, static_cast< unsigned char >( i ) );
+            BOOST_TEST_EQ( sv.find_last_of( needle ), 255 - i );
+        }
+    }
+
+    {
+        wchar_t str[ 256 ];
+
+        for( int i = 0; i < 256; ++i )
+        {
+            str[ i ] = static_cast< wchar_t >( 0x100 + i );
+        }
+
+        boost::core::wstring_view sv( str, 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring needle( 12, static_cast< wchar_t >( 0x100 + i ) );
+            BOOST_TEST_EQ( sv.find_first_of( needle ), i );
+        }
+
+        std::reverse( str, str + 256 );
+
+        for( int i = 0; i < 256; ++i )
+        {
+            std::wstring needle( 12, static_cast< wchar_t >( 0x100 + i ) );
+            BOOST_TEST_EQ( sv.find_first_of( needle ), 255 - i );
+        }
+    }
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    {
+        boost::core::u8string_view sv( u8"123123" );
+
+        BOOST_TEST_EQ( sv.find_last_of( u8"", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"", 6 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"", 7 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"" ), npos );
+
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 1 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 2 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1", 7 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"1" ), 3 );
+
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 3 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"23" ), 5 );
+
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 0 ), 0 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 2 ), 2 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 5 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 6 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123", 7 ), 5 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"123" ), 5 );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"abc1abc2abc3" );
+
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"0123456789" ), 11 );
+    }
+
+    {
+        boost::core::u8string_view sv( u8"123a123B123c" );
+
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 1 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 2 ), npos );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 4 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 5 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 6 ), 3 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 7 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 10 ), 7 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 11 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12 ), 11 );
+        BOOST_TEST_EQ( sv.find_last_of( u8"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ), 11 );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/sv_find_test.cpp

@@ -0,0 +1,130 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view() ), 0 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view(), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "" ) ), 0 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ) ), npos );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ), 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( '1' ), npos );
+        BOOST_TEST_EQ( sv.find( '1', 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "" ), 0 );
+        BOOST_TEST_EQ( sv.find( "", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "1" ), npos );
+        BOOST_TEST_EQ( sv.find( "1", 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "1", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find( "1", 1, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "1", 0, 1 ), npos );
+        BOOST_TEST_EQ( sv.find( "1", 1, 1 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view() ), 0 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view(), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view(), 6 ), 6 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view(), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "" ) ), 0 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "" ), 6 ), 6 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ) ), 0 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ), 1 ), 3 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ), 4 ), npos );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "1" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ) ), 1 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ), 2 ), 4 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ), 5 ), npos );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ), 6 ), npos );
+        BOOST_TEST_EQ( sv.find( boost::core::string_view( "23" ), 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( '1' ), 0 );
+        BOOST_TEST_EQ( sv.find( '1', 1 ), 3 );
+        BOOST_TEST_EQ( sv.find( '1', 2 ), 3 );
+        BOOST_TEST_EQ( sv.find( '1', 3 ), 3 );
+        BOOST_TEST_EQ( sv.find( '1', 4 ), npos );
+        BOOST_TEST_EQ( sv.find( '1', 5 ), npos );
+        BOOST_TEST_EQ( sv.find( '1', 6 ), npos );
+        BOOST_TEST_EQ( sv.find( '1', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( '3' ), 2 );
+        BOOST_TEST_EQ( sv.find( '3', 1 ), 2 );
+        BOOST_TEST_EQ( sv.find( '3', 2 ), 2 );
+        BOOST_TEST_EQ( sv.find( '3', 3 ), 5 );
+        BOOST_TEST_EQ( sv.find( '3', 4 ), 5 );
+        BOOST_TEST_EQ( sv.find( '3', 5 ), 5 );
+        BOOST_TEST_EQ( sv.find( '3', 6 ), npos );
+        BOOST_TEST_EQ( sv.find( '3', 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( '9' ), npos );
+
+        BOOST_TEST_EQ( sv.find( "" ), 0 );
+        BOOST_TEST_EQ( sv.find( "", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find( "", 6 ), 6 );
+        BOOST_TEST_EQ( sv.find( "", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "1" ), 0 );
+        BOOST_TEST_EQ( sv.find( "1", 1 ), 3 );
+        BOOST_TEST_EQ( sv.find( "1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.find( "1", 4 ), npos );
+        BOOST_TEST_EQ( sv.find( "1", 6 ), npos );
+        BOOST_TEST_EQ( sv.find( "1", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "23" ), 1 );
+        BOOST_TEST_EQ( sv.find( "23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.find( "23", 2 ), 4 );
+        BOOST_TEST_EQ( sv.find( "23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.find( "23", 5 ), npos );
+        BOOST_TEST_EQ( sv.find( "23", 6 ), npos );
+        BOOST_TEST_EQ( sv.find( "23", 7 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "123", 0, 0 ), 0 );
+        BOOST_TEST_EQ( sv.find( "123", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.find( "123", 6, 0 ), 6 );
+        BOOST_TEST_EQ( sv.find( "123", 7, 0 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "123", 0, 1 ), 0 );
+        BOOST_TEST_EQ( sv.find( "123", 1, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find( "123", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.find( "123", 4, 1 ), npos );
+        BOOST_TEST_EQ( sv.find( "123", 6, 1 ), npos );
+        BOOST_TEST_EQ( sv.find( "123", 7, 1 ), npos );
+
+        BOOST_TEST_EQ( sv.find( "123", 0, 3 ), 0 );
+        BOOST_TEST_EQ( sv.find( "123", 1, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find( "123", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.find( "123", 4, 3 ), npos );
+        BOOST_TEST_EQ( sv.find( "123", 6, 3 ), npos );
+        BOOST_TEST_EQ( sv.find( "123", 7, 3 ), npos );
+    }
+
+    return boost::report_errors();
+}

test/sv_iteration_test.cpp

@@ -0,0 +1,61 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+#include <algorithm>
+
+int main()
+{
+    {
+        boost::core::string_view sv;
+
+        {
+            std::string s( sv.begin(), sv.end() );
+            BOOST_TEST_EQ( s, std::string( "" ) );
+        }
+
+        {
+            std::string s( sv.cbegin(), sv.cend() );
+            BOOST_TEST_EQ( s, std::string( "" ) );
+        }
+
+        {
+            std::string s( sv.rbegin(), sv.rend() );
+            BOOST_TEST_EQ( s, std::string( "" ) );
+        }
+
+        {
+            std::string s( sv.crbegin(), sv.crend() );
+            BOOST_TEST_EQ( s, std::string( "" ) );
+        }
+    }
+
+    {
+        boost::core::string_view sv( "123" );
+
+        {
+            std::string s( sv.begin(), sv.end() );
+            BOOST_TEST_EQ( s, std::string( "123" ) );
+        }
+
+        {
+            std::string s( sv.cbegin(), sv.cend() );
+            BOOST_TEST_EQ( s, std::string( "123" ) );
+        }
+
+        {
+            std::string s( sv.rbegin(), sv.rend() );
+            BOOST_TEST_EQ( s, std::string( "321" ) );
+        }
+
+        {
+            std::string s( sv.crbegin(), sv.crend() );
+            BOOST_TEST_EQ( s, std::string( "321" ) );
+        }
+    }
+
+    return boost::report_errors();
+}

test/sv_lt_test.cpp

@@ -0,0 +1,109 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cstddef>
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# include <memory_resource>
+#endif
+
+#define TEST_LT(x, y) \
+    BOOST_TEST_LT(x, y); \
+    BOOST_TEST_LE(x, y); \
+    BOOST_TEST_NE(x, y); \
+    BOOST_TEST_NOT((x) == (y)); \
+    BOOST_TEST_NOT((x) >= (y)); \
+    BOOST_TEST_NOT((x) > (y)); \
+    BOOST_TEST_GT(y, x); \
+    BOOST_TEST_GE(y, x); \
+    BOOST_TEST_NOT((y) < (x)); \
+    BOOST_TEST_NOT((y) <= (x));
+
+int main()
+{
+    {
+        boost::core::string_view sv0( "" );
+        boost::core::string_view sv1( "12" );
+        boost::core::string_view sv2( "122" );
+        boost::core::string_view sv3( "123" );
+        boost::core::string_view sv4( "124" );
+        boost::core::string_view sv5( "1234" );
+
+        TEST_LT( sv0, sv1 );
+        TEST_LT( sv1, sv2 );
+        TEST_LT( sv2, sv3 );
+        TEST_LT( sv3, sv4 );
+        TEST_LT( sv3, sv5 );
+        TEST_LT( sv5, sv4 );
+
+        TEST_LT( sv0, std::string( "12" ) );
+        TEST_LT( sv1, std::string( "122" ) );
+        TEST_LT( sv2, std::string( "123" ) );
+        TEST_LT( sv3, std::string( "124" ) );
+        TEST_LT( sv3, std::string( "1234" ) );
+        TEST_LT( sv5, std::string( "124" ) );
+
+        TEST_LT( sv0, "12" );
+        TEST_LT( sv1, "122" );
+        TEST_LT( sv2, "123" );
+        TEST_LT( sv3, "124" );
+        TEST_LT( sv3, "1234" );
+        TEST_LT( sv5, "124" );
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+        TEST_LT( sv0, std::string_view( "12" ) );
+        TEST_LT( sv1, std::string_view( "122" ) );
+        TEST_LT( sv2, std::string_view( "123" ) );
+        TEST_LT( sv3, std::string_view( "124" ) );
+        TEST_LT( sv3, std::string_view( "1234" ) );
+        TEST_LT( sv5, std::string_view( "124" ) );
+
+#endif
+
+        TEST_LT( std::string( "" ), sv1 );
+        TEST_LT( std::string( "12" ), sv2 );
+        TEST_LT( std::string( "122" ), sv3 );
+        TEST_LT( std::string( "123" ), sv4 );
+        TEST_LT( std::string( "123" ), sv5 );
+        TEST_LT( std::string( "1234" ), sv4 );
+
+        TEST_LT( "", sv1 );
+        TEST_LT( "12", sv2 );
+        TEST_LT( "122", sv3 );
+        TEST_LT( "123", sv4 );
+        TEST_LT( "123", sv5 );
+        TEST_LT( "1234", sv4 );
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+        TEST_LT( std::string_view( "" ), sv1 );
+        TEST_LT( std::string_view( "12" ), sv2 );
+        TEST_LT( std::string_view( "122" ), sv3 );
+        TEST_LT( std::string_view( "123" ), sv4 );
+        TEST_LT( std::string_view( "123" ), sv5 );
+        TEST_LT( std::string_view( "1234" ), sv4 );
+
+#endif
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+
+        using pmr_string = std::basic_string<char, std::char_traits<char>, std::pmr::polymorphic_allocator<char>>;
+
+        TEST_LT( pmr_string( "" ), sv1 );
+        TEST_LT( pmr_string( "12" ), sv2 );
+        TEST_LT( pmr_string( "122" ), sv3 );
+        TEST_LT( pmr_string( "123" ), sv4 );
+        TEST_LT( pmr_string( "123" ), sv5 );
+        TEST_LT( pmr_string( "1234" ), sv4 );
+
+#endif
+    }
+
+    return boost::report_errors();
+}

test/sv_modifiers_test.cpp

@@ -0,0 +1,127 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cstddef>
+
+int main()
+{
+    {
+        char const* s1 = "12345";
+        char const* s2 = "";
+
+        boost::core::string_view sv1( s1 );
+        boost::core::string_view sv2( s2 );
+
+        sv1.swap( sv2 );
+
+        BOOST_TEST_EQ( sv1.data(), s2 );
+        BOOST_TEST_EQ( sv1.size(), 0 );
+
+        BOOST_TEST_EQ( sv2.data(), s1 );
+        BOOST_TEST_EQ( sv2.size(), 5);
+    }
+
+    {
+        boost::core::string_view sv;
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_prefix( 0 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size );
+
+        sv.remove_suffix( 0 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size );
+    }
+
+    {
+        boost::core::string_view sv( "" );
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_prefix( 0 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size );
+
+        sv.remove_suffix( 0 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_prefix( 0 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size );
+
+        sv.remove_suffix( 0 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_prefix( 2 );
+
+        BOOST_TEST_EQ( sv.data(), data + 2 );
+        BOOST_TEST_EQ( sv.size(), size - 2 );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_prefix( 5 );
+
+        BOOST_TEST_EQ( sv.data(), data + 5 );
+        BOOST_TEST_EQ( sv.size(), size - 5 );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_suffix( 2 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size - 2 );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+
+        char const* data = sv.data();
+        std::size_t size = sv.size();
+
+        sv.remove_suffix( 5 );
+
+        BOOST_TEST_EQ( sv.data(), data );
+        BOOST_TEST_EQ( sv.size(), size - 5 );
+    }
+
+    return boost::report_errors();
+}

test/sv_rfind_test.cpp

@@ -0,0 +1,169 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cstddef>
+
+int main()
+{
+    std::size_t const npos = boost::core::string_view::npos;
+
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view() ), 0 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ) ), 0 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ) ), npos );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 1 ), npos );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 0 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( '1' ), npos );
+        BOOST_TEST_EQ( sv.rfind( '1', 1 ), npos );
+        BOOST_TEST_EQ( sv.rfind( '1', 0 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( "" ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "", 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "", 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "1" ), npos );
+        BOOST_TEST_EQ( sv.rfind( "1", 1 ), npos );
+        BOOST_TEST_EQ( sv.rfind( "1", 0 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( "1", npos, 0 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "1", 1, 0 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "1", 0, 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "1", npos, 1 ), npos );
+        BOOST_TEST_EQ( sv.rfind( "1", 1, 1 ), npos );
+        BOOST_TEST_EQ( sv.rfind( "1", 0, 1 ), npos );
+    }
+
+    {
+        boost::core::string_view sv( "123123" );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view() ), 6 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 7 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 6 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 5 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 1 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view(), 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ) ), 6 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 7 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 6 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 5 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "" ), 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ) ), 3 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 7 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 6 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 5 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 4 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 2 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "1" ), 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ) ), 4 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 7 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 6 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 5 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 4 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 3 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 2 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 1 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( boost::core::string_view( "23" ), 0 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( '1' ), 3 );
+        BOOST_TEST_EQ( sv.rfind( '1', 7 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( '1', 6 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( '1', 5 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( '1', 4 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( '1', 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( '1', 2 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( '1', 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( '1', 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( '3' ), 5 );
+        BOOST_TEST_EQ( sv.rfind( '3', 7 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( '3', 6 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( '3', 5 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( '3', 4 ), 2 );
+        BOOST_TEST_EQ( sv.rfind( '3', 3 ), 2 );
+        BOOST_TEST_EQ( sv.rfind( '3', 2 ), 2 );
+        BOOST_TEST_EQ( sv.rfind( '3', 1 ), npos );
+        BOOST_TEST_EQ( sv.rfind( '3', 0 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( '9' ), npos );
+        BOOST_TEST_EQ( sv.rfind( '9', 7 ), npos );
+        BOOST_TEST_EQ( sv.rfind( '9', 6 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( "" ), 6 );
+        BOOST_TEST_EQ( sv.rfind( "", 7 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( "", 6 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( "", 5 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( "", 1 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( "", 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "1" ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "1", 7 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "1", 6 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "1", 5 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "1", 4 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "1", 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "1", 2 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "1", 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "1", 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "23" ), 4 );
+        BOOST_TEST_EQ( sv.rfind( "23", 7 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( "23", 6 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( "23", 5 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( "23", 4 ), 4 );
+        BOOST_TEST_EQ( sv.rfind( "23", 3 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( "23", 2 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( "23", 1 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( "23", 0 ), npos );
+
+        BOOST_TEST_EQ( sv.rfind( "123", npos, 0 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( "123", 7, 0 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( "123", 6, 0 ), 6 );
+        BOOST_TEST_EQ( sv.rfind( "123", 5, 0 ), 5 );
+        BOOST_TEST_EQ( sv.rfind( "123", 1, 0 ), 1 );
+        BOOST_TEST_EQ( sv.rfind( "123", 0, 0 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "123", npos, 1 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 7, 1 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 6, 1 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 5, 1 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 4, 1 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 3, 1 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 2, 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "123", 1, 1 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "123", 0, 1 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "123", npos, 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 7, 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 6, 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 5, 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 4, 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 3, 3 ), 3 );
+        BOOST_TEST_EQ( sv.rfind( "123", 2, 3 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "123", 1, 3 ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "123", 0, 3 ), 0 );
+
+        BOOST_TEST_EQ( sv.rfind( "123123" ), 0 );
+        BOOST_TEST_EQ( sv.rfind( "1231231" ), npos );
+    }
+
+    return boost::report_errors();
+}

test/sv_starts_with_test.cpp

@@ -0,0 +1,50 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+#include <cstddef>
+
+int main()
+{
+    {
+        boost::core::string_view sv( "" );
+
+        BOOST_TEST( sv.starts_with( boost::core::string_view() ) );
+        BOOST_TEST( sv.starts_with( boost::core::string_view( "" ) ) );
+        BOOST_TEST( sv.starts_with( "" ) );
+
+        BOOST_TEST( !sv.starts_with( boost::core::string_view( "1" ) ) );
+        BOOST_TEST( !sv.starts_with( '1' ) );
+        BOOST_TEST( !sv.starts_with( "1" ) );
+    }
+
+    {
+        boost::core::string_view sv( "123" );
+
+        BOOST_TEST( sv.starts_with( boost::core::string_view() ) );
+        BOOST_TEST( sv.starts_with( boost::core::string_view( "" ) ) );
+        BOOST_TEST( sv.starts_with( "" ) );
+
+        BOOST_TEST( sv.starts_with( boost::core::string_view( "1" ) ) );
+        BOOST_TEST( sv.starts_with( '1' ) );
+        BOOST_TEST( sv.starts_with( "1" ) );
+
+        BOOST_TEST( sv.starts_with( boost::core::string_view( "12" ) ) );
+        BOOST_TEST( sv.starts_with( "12" ) );
+
+        BOOST_TEST( sv.starts_with( boost::core::string_view( "123" ) ) );
+        BOOST_TEST( sv.starts_with( "123" ) );
+
+        BOOST_TEST( !sv.starts_with( boost::core::string_view( "1234" ) ) );
+        BOOST_TEST( !sv.starts_with( "1234" ) );
+
+        BOOST_TEST( !sv.starts_with( boost::core::string_view( "2" ) ) );
+        BOOST_TEST( !sv.starts_with( '2' ) );
+        BOOST_TEST( !sv.starts_with( "2" ) );
+    }
+
+    return boost::report_errors();
+}

test/sv_stream_insert_test.cpp

@@ -0,0 +1,111 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <iomanip>
+
+int main()
+{
+    using boost::core::string_view;
+
+    {
+        std::ostringstream os;
+
+        os << string_view( "" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "123" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setw( 5 ) << string_view( "" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "     " ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setfill( '-' ) << std::setw( 5 ) << string_view( "" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "-----" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setw( 5 ) << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "  123" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::left << std::setw( 5 ) << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "123  " ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::right << std::setw( 5 ) << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "  123" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setfill( '-' ) << std::setw( 5 ) << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "--123" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setfill( '-' ) << std::left << std::setw( 5 ) << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "123--" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setfill( '-' ) << std::right << std::setw( 5 ) << string_view( "123" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "--123" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setw( 5 ) << string_view( "12345" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "12345" ) );
+    }
+
+    {
+        std::ostringstream os;
+
+        os << std::setw( 5 ) << string_view( "1234567" );
+
+        BOOST_TEST_EQ( os.str(), std::string( "1234567" ) );
+    }
+
+    return boost::report_errors();
+}

test/sv_substr_test.cpp

@@ -0,0 +1,203 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+#include <cstddef>
+
+int main()
+{
+    {
+        boost::core::string_view sv;
+
+        {
+            boost::core::string_view sv2 = sv.substr();
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), sv.size() );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), sv.size() );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 1 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos ), std::out_of_range );
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0, 1 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), sv.size() );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0, 0 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), sv.size() );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 1, 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos, 0 ), std::out_of_range );
+    }
+
+    {
+        boost::core::string_view sv( "12345" );
+
+        {
+            boost::core::string_view sv2 = sv.substr();
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), sv.size() );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), sv.size() );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 2 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 2 );
+            BOOST_TEST_EQ( sv2.size(), sv.size() - 2 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 5 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 5 );
+            BOOST_TEST_EQ( sv2.size(), sv.size() - 5 );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 6 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos ), std::out_of_range );
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0, 0 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), 0 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 2, 0 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 2 );
+            BOOST_TEST_EQ( sv2.size(), 0 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 5, 0 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 5 );
+            BOOST_TEST_EQ( sv2.size(), 0 );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 6, 0 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos, 0 ), std::out_of_range );
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0, 3 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), 3 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 2, 3 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 2 );
+            BOOST_TEST_EQ( sv2.size(), 3 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 4, 3 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 4 );
+            BOOST_TEST_EQ( sv2.size(), 1 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 5, 3 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 5 );
+            BOOST_TEST_EQ( sv2.size(), 0 );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 6, 3 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos, 3 ), std::out_of_range );
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0, 5 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), 5 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 2, 5 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 2 );
+            BOOST_TEST_EQ( sv2.size(), 3 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 4, 5 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 4 );
+            BOOST_TEST_EQ( sv2.size(), 1 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 5, 5 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 5 );
+            BOOST_TEST_EQ( sv2.size(), 0 );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 6, 5 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos, 5 ), std::out_of_range );
+
+        {
+            boost::core::string_view sv2 = sv.substr( 0, 8 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() );
+            BOOST_TEST_EQ( sv2.size(), 5 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 2, 8 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 2 );
+            BOOST_TEST_EQ( sv2.size(), 3 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 4, 8 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 4 );
+            BOOST_TEST_EQ( sv2.size(), 1 );
+        }
+
+        {
+            boost::core::string_view sv2 = sv.substr( 5, 8 );
+
+            BOOST_TEST_EQ( sv2.data(), sv.data() + 5 );
+            BOOST_TEST_EQ( sv2.size(), 0 );
+        }
+
+        BOOST_TEST_THROWS( sv.substr( 6, 8 ), std::out_of_range );
+        BOOST_TEST_THROWS( sv.substr( boost::core::string_view::npos, 8 ), std::out_of_range );
+    }
+
+    return boost::report_errors();
+}

test/sv_types_test.cpp

@@ -0,0 +1,47 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/is_same.hpp>
+#include <iterator>
+
+struct Ch
+{
+};
+
+int main()
+{
+    typedef boost::core::basic_string_view<Ch> ch_string_view;
+
+    BOOST_TEST_TRAIT_SAME(ch_string_view::traits_type, std::char_traits<Ch>);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::value_type, Ch);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::pointer, Ch*);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::const_pointer, Ch const*);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::reference, Ch&);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::const_reference, Ch const&);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::iterator, ch_string_view::const_iterator);
+    BOOST_TEST_TRAIT_SAME(std::iterator_traits<ch_string_view::iterator>::iterator_category, std::random_access_iterator_tag);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::reverse_iterator, ch_string_view::const_reverse_iterator);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::reverse_iterator, std::reverse_iterator<ch_string_view::iterator>);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::size_type, std::size_t);
+    BOOST_TEST_TRAIT_SAME(ch_string_view::difference_type, std::ptrdiff_t);
+
+    BOOST_TEST_EQ(ch_string_view::npos, static_cast<std::size_t>(-1));
+
+    BOOST_TEST_TRAIT_SAME(boost::core::string_view, boost::core::basic_string_view<char>);
+    BOOST_TEST_TRAIT_SAME(boost::core::wstring_view, boost::core::basic_string_view<wchar_t>);
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_TEST_TRAIT_SAME(boost::core::u16string_view, boost::core::basic_string_view<char16_t>);
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_TEST_TRAIT_SAME(boost::core::u32string_view, boost::core::basic_string_view<char32_t>);
+#endif
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+    BOOST_TEST_TRAIT_SAME(boost::core::u8string_view, boost::core::basic_string_view<char8_t>);
+#endif
+
+    return boost::report_errors();
+}

test/swap/swap_array_of_array_of_class.cpp

@@ -17,6 +17,10 @@
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
 //Provide swap function in both the namespace of swap_test_class
 //(which is the global namespace), and the std namespace.
 //It's common to provide a swap function for a class in both

test/swap/swap_array_of_class.cpp

@@ -17,6 +17,10 @@
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
 //Provide swap function in both the namespace of swap_test_class
 //(which is the global namespace), and the std namespace.
 //It's common to provide a swap function for a class in both

test/swap/swap_array_of_template.cpp

@@ -50,8 +50,8 @@ void swap(swap_test_template<T>& left, swap_test_template<T>& right)
 int main()
 {
   const std::size_t array_size = 2;
-  const swap_test_template<int> initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
-  const swap_test_template<int> initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
+  const swap_test_template<int> initial_array1[array_size] = { { swap_test_class(1) }, { swap_test_class(2) } };
+  const swap_test_template<int> initial_array2[array_size] = { { swap_test_class(3) }, { swap_test_class(4) } };
   
   swap_test_template<int> array1[array_size];
   swap_test_template<int> array2[array_size];

test/test_lib_typeid2.cpp

@@ -0,0 +1,34 @@
+
+// Copyright 2018, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+boost::core::typeinfo const & get_typeid_X();
+
+struct BOOST_SYMBOL_VISIBLE X
+{
+};
+
+struct Y
+{
+};
+
+int main()
+{
+    boost::core::typeinfo const & tx = BOOST_CORE_TYPEID( X );
+    boost::core::typeinfo const & ty = BOOST_CORE_TYPEID( Y );
+
+    boost::core::typeinfo const & tx2 = get_typeid_X();
+
+    BOOST_TEST( tx2 == tx );
+    BOOST_TEST( tx2 != ty );
+
+    BOOST_TEST( !tx2.before( tx ) );
+    BOOST_TEST( !tx.before( tx2 ) );
+
+    BOOST_TEST( tx2.before( ty ) != ty.before( tx2 ) );
+
+    return boost::report_errors();
+}

test/to_address_test.cpp

@@ -124,7 +124,7 @@ struct pointer_traits<P6<T> > {
 namespace std {
 template<class T>
 struct pointer_traits<P6<T> > {
-    static T* to_address(const P6<T>& p) BOOST_NOEXCEPT {
+    static T* to_address(const P6<T>& /*p*/) BOOST_NOEXCEPT {
         return 0;
     }
 };

test/type_name_test.cpp

@@ -0,0 +1,383 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/type_name.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <string>
+#include <vector>
+#include <list>
+#include <deque>
+#include <set>
+#include <map>
+#include <utility>
+#include <cstddef>
+#include <iosfwd>
+
+#if !defined(BOOST_NO_CXX11_HDR_UNORDERED_SET)
+# include <unordered_set>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP)
+# include <unordered_map>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+# include <array>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+# include <tuple>
+#endif
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+
+//
+
+#define TEST(...) BOOST_TEST_EQ((boost::core::type_name<__VA_ARGS__>()), std::string(#__VA_ARGS__))
+
+struct A
+{
+};
+
+class B
+{
+};
+
+template<class T1, class T2> struct X
+{
+};
+
+enum E1
+{
+    e1
+};
+
+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
+enum class E2
+{
+    e2
+};
+
+#endif
+
+struct Ch
+{
+};
+
+int main()
+{
+    TEST(signed char);
+    TEST(unsigned char);
+    TEST(short);
+    TEST(unsigned short);
+    TEST(int);
+    TEST(unsigned);
+    TEST(long);
+    TEST(unsigned long);
+    TEST(long long);
+    TEST(unsigned long long);
+
+    TEST(char);
+    TEST(wchar_t);
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    TEST(char16_t);
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    TEST(char32_t);
+#endif
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+    TEST(char8_t);
+#endif
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
+    TEST(std::byte);
+#endif
+
+    TEST(bool);
+
+    TEST(float);
+    TEST(double);
+    TEST(long double);
+
+    TEST(void);
+    TEST(void const);
+    TEST(void volatile);
+    TEST(void const volatile);
+
+    TEST(A);
+    TEST(B);
+
+    TEST(E1);
+
+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
+    TEST(E2);
+
+#endif
+
+    TEST(A const);
+    TEST(A volatile);
+    TEST(A const volatile);
+
+    TEST(B&);
+    TEST(B const&);
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+    TEST(B&&);
+    TEST(B const&&);
+
+#endif
+
+    TEST(A*);
+    TEST(B const* volatile*);
+
+    TEST(void*);
+    TEST(void const* volatile*);
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+    TEST(void());
+    TEST(int(float, A, B*));
+
+    TEST(void(*)());
+    TEST(void(**)());
+    TEST(void(***)());
+
+    TEST(void(* const* const*)());
+    TEST(void(* const* const&)());
+
+    TEST(void(&)());
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+    TEST(void(&&)());
+
+#endif
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
+
+    TEST(void() const);
+    TEST(void() volatile);
+    TEST(void() const volatile);
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+
+    TEST(void() &);
+    TEST(void() const &);
+    TEST(void() volatile &);
+    TEST(void() const volatile &);
+
+    TEST(void() &&);
+    TEST(void() const &&);
+    TEST(void() volatile &&);
+    TEST(void() const volatile &&);
+
+#endif
+
+#if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED )
+
+    TEST(void() noexcept);
+    TEST(void() const noexcept);
+    TEST(void() volatile noexcept);
+    TEST(void() const volatile noexcept);
+
+    TEST(void() & noexcept);
+    TEST(void() const & noexcept);
+    TEST(void() volatile & noexcept);
+    TEST(void() const volatile & noexcept);
+
+    TEST(void() && noexcept);
+    TEST(void() const && noexcept);
+    TEST(void() volatile && noexcept);
+    TEST(void() const volatile && noexcept);
+
+#endif
+
+#endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+    TEST(A[]);
+    TEST(A const[]);
+    TEST(A volatile[]);
+    TEST(A const volatile[]);
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1700
+    TEST(A(&)[]);
+#endif
+    TEST(A const(***)[]);
+
+    TEST(B[1]);
+    TEST(B const[1]);
+    TEST(B volatile[1]);
+    TEST(B const volatile[1]);
+
+    TEST(B(&)[1]);
+    TEST(B const(***)[1]);
+
+    TEST(A[][2][3]);
+    TEST(A const[][2][3]);
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1700
+    TEST(A(&)[][2][3]);
+#endif
+    TEST(A const(***)[][2][3]);
+
+    TEST(B[1][2][3]);
+    TEST(B const volatile[1][2][3]);
+
+    TEST(B(&)[1][2][3]);
+    TEST(B const volatile(***)[1][2][3]);
+
+    TEST(int A::*);
+    TEST(int const B::*);
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+    TEST(void(A::*)());
+    TEST(void(A::*)() const);
+    TEST(void(A::*)() volatile);
+    TEST(void(A::*)() const volatile);
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+
+    TEST(void(A::*)() &);
+    TEST(void(A::*)() const &&);
+
+#endif
+
+#if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED )
+
+    TEST(void(A::*)() volatile & noexcept);
+    TEST(void(A::*)() const volatile && noexcept);
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+
+    TEST(std::nullptr_t);
+
+#endif
+
+    TEST(std::pair<A, B>);
+    TEST(std::pair<A const*, B*> volatile&);
+
+    TEST(std::pair<void, void>);
+    TEST(std::pair<std::pair<void, void>, void>);
+
+    TEST(std::basic_string<Ch>);
+
+    TEST(std::string);
+    TEST(std::wstring);
+
+#if BOOST_CXX_VERSION >= 201100L
+
+    TEST(std::u16string);
+    TEST(std::u32string);
+
+#endif
+
+#if BOOST_CXX_VERSION >= 202000L
+
+    TEST(std::u8string);
+
+#endif
+
+    TEST(X<A, B>);
+    TEST(X<A const&, B&> volatile&);
+
+    TEST(X<std::pair<void, void>, void>);
+
+    TEST(std::vector<int>);
+    TEST(std::vector<A>);
+    TEST(std::vector<std::string>);
+
+    TEST(std::list<int>);
+    TEST(std::list<B>);
+    TEST(std::list<std::wstring>);
+
+    TEST(std::deque<int>);
+    TEST(std::deque<A>);
+    TEST(std::deque<std::string>);
+
+    TEST(std::set<int>);
+    TEST(std::set<B>);
+    TEST(std::set<std::string>);
+
+    TEST(std::map<int, A>);
+    TEST(std::map<std::string, B>);
+    TEST(std::map<std::wstring, std::vector<std::string> const*> const&);
+
+#if !defined(BOOST_NO_CXX11_HDR_UNORDERED_SET)
+
+    TEST(std::unordered_set<int>);
+    TEST(std::unordered_set<std::string>);
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP)
+
+    TEST(std::unordered_map<int, A>);
+    TEST(std::unordered_map<std::string, B>);
+    TEST(std::unordered_map<std::wstring, std::set<std::string>*>);
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+
+    TEST(std::array<std::string, 7>);
+    TEST(std::array<std::wstring const*, 0> const&);
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && ( !defined(BOOST_MSVC) || BOOST_MSVC >= 1700 )
+
+    TEST(std::tuple<>);
+    TEST(std::tuple<int>);
+    TEST(std::tuple<int, float>);
+    TEST(std::tuple<int, float, std::string>);
+
+    TEST(std::tuple<void>);
+    TEST(std::tuple<void, void>);
+    TEST(std::tuple<void, void, void>);
+
+    TEST(std::tuple<std::tuple<void, void>, void>);
+
+    TEST(X<std::tuple<void>, void>);
+
+#endif
+
+    TEST(std::ostream);
+    TEST(std::basic_ostream<wchar_t>);
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+    TEST(std::basic_string_view<Ch>);
+
+    TEST(std::string_view);
+    TEST(std::wstring_view);
+
+#if BOOST_CXX_VERSION >= 201100L
+
+    TEST(std::u16string_view);
+    TEST(std::u32string_view);
+
+#endif
+
+#if BOOST_CXX_VERSION >= 202000L
+
+    TEST(std::u8string_view);
+
+#endif
+
+#endif
+
+    return boost::report_errors();
+}

test/uncaught_exceptions.cpp

@@ -18,6 +18,10 @@
 #include <boost/core/uncaught_exceptions.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4512) // assignment operator could not be generated
+#endif
+
 struct my_exception {};
 
 class exception_watcher

test/uncaught_exceptions_np.cpp

@@ -20,6 +20,10 @@
 
 #include <boost/core/lightweight_test.hpp>
 
+#if defined(_MSC_VER)
+# pragma warning(disable: 4512) // assignment operator could not be generated
+#endif
+
 struct my_exception1 {};
 struct my_exception2 {};