Fix ccache saving on cache hit (#26)

See boostorg/boost-ci#166

.appveyor.yml

@@ -0,0 +1,116 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2017 - 2019 James E. King III
+# Copyright 2019 - 2021 Alexander Grund
+# 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)
+
+#
+# Generic Appveyor build script for boostorg repositories
+# See: https://github.com/boostorg/boost-ci/
+#
+# Instructions for customizing this script for your library:
+#
+# 1. Customize the compilers and language levels you want.
+# 2. If you have more than include/, src/, test/, example/, examples/,
+#    benchmark/ or tools/ directories, set the environment variable DEPINST.
+#    For example if your build uses code in "bench/" and "fog/" directories:
+#      - DEPINST: --include bench --include fog
+# 3. Enable pull request builds in your boostorg/<library> account.
+#
+# That's it - the script will do everything else for you.
+#
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /bugfix\/.*/
+    - /feature\/.*/
+    - /fix\/.*/
+    - /pr\/.*/
+
+matrix:
+  fast_finish: false
+  # Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
+  allow_failures:
+    - MAYFAIL: true
+
+environment:
+  global:
+    SELF: logic
+    B2_CI_VERSION: 1
+    GIT_FETCH_JOBS: 4
+    # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
+    # to use the default for a given environment, comment it out; recommend you build debug and release however:
+    # on Windows it is important to exercise all the possibilities, especially shared vs static, however most
+    # libraries that care about this exercise it in their Jamfiles...
+    B2_ADDRESS_MODEL: 32,64
+    B2_LINK: shared,static
+    # B2_THREADING: threading=multi,single
+    B2_VARIANT: release
+
+  matrix:
+    - FLAVOR: Visual Studio 2017 C++2a Strict
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 2a
+      B2_TOOLSET: msvc-14.1
+
+    - FLAVOR: Visual Studio 2017 C++14/17
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_CXXSTD: 14,17
+      B2_TOOLSET: msvc-14.1
+
+    - FLAVOR: clang-cl
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_ADDRESS_MODEL: 64
+      B2_CXXSTD: 11,14,17
+      B2_TOOLSET: clang-win
+
+    - FLAVOR: Visual Studio 2015, 2013
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      B2_TOOLSET: msvc-12.0,msvc-14.0
+
+    - FLAVOR: cygwin (32-bit)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ADDPATH: C:\cygwin\bin;
+      B2_ADDRESS_MODEL: 32
+      B2_CXXSTD: 03,11,14,1z
+      B2_TOOLSET: gcc
+
+    - FLAVOR: cygwin (64-bit)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ADDPATH: C:\cygwin64\bin;
+      B2_ADDRESS_MODEL: 64
+      B2_CXXSTD: 03,11,14,1z
+      B2_TOOLSET: gcc
+
+    - FLAVOR: mingw32
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      B2_ADDRESS_MODEL: 32
+      ADDPATH: C:\mingw\bin;
+      B2_CXXSTD: 03,11,14,1z
+      B2_TOOLSET: gcc
+
+    - FLAVOR: mingw64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
+      B2_ADDRESS_MODEL: 64
+      B2_CXXSTD: 03,11,14,17,2a
+      B2_TOOLSET: gcc
+
+install:
+  - git clone --depth 1 https://github.com/boostorg/boost-ci.git C:\boost-ci-cloned
+  # Copy ci folder if not testing Boost.CI
+  - if NOT "%APPVEYOR_PROJECT_NAME%" == "boost-ci" xcopy /s /e /q /i /y C:\boost-ci-cloned\ci .\ci
+  - rmdir /s /q C:\boost-ci-cloned
+  - ci\appveyor\install.bat
+
+build: off
+
+test_script: ci\build.bat
+

.codecov.yml

@@ -0,0 +1,31 @@
+# Copyright 2019 - 2021 Alexander Grund
+# 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)
+#
+# Sample codecov configuration file. Edit as required
+
+codecov:
+  max_report_age: off
+  require_ci_to_pass: yes
+  notify:
+    # Increase this if you have multiple coverage collection jobs
+    after_n_builds: 2
+    wait_for_ci: yes
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: yes
+      loop: yes
+      method: no
+      macro: no
+
+# Change how pull request comments look
+comment:
+  layout: "reach,diff,flags,files,footer"
+
+# Ignore specific files or folders. Glob patterns are supported.
+# See https://docs.codecov.com/docs/ignoring-paths
+ignore:
+  - libs/logic/test/
+  - test/

.github/workflows/ci.yml

@@ -0,0 +1,340 @@
+# Copyright 2020-2021 Peter Dimov
+# Copyright 2021 Andrey Semashev
+# Copyright 2021 Alexander Grund
+# Copyright 2022 James E. King III
+#
+# 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
+      - bugfix/**
+      - feature/**
+      - fix/**
+      - pr/**
+
+concurrency:
+  group: ${{format('{0}:{1}', github.repository, github.ref)}}
+  cancel-in-progress: true
+
+env:
+  SELF: logic
+  ASAN_OPTIONS: allocator_may_return_null=1
+  GIT_FETCH_JOBS: 8
+  NET_RETRY_COUNT: 5
+  B2_CI_VERSION: 1
+  B2_VARIANT: debug,release
+  B2_LINK: shared,static
+  LCOV_BRANCH_COVERAGE: 0
+  CODECOV_NAME: Github Actions
+
+jobs:
+  posix:
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux, gcc
+          - { compiler: gcc-4.4,   cxxstd: '98,0x',          os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: gcc-4.6,   cxxstd: '03,0x',          os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: gcc-4.7,   cxxstd: '03,11',          os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: gcc-4.8,   cxxstd: '03,11',          os: ubuntu-18.04 }
+          - { compiler: gcc-4.9,   cxxstd: '03,11',          os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: gcc-5,     cxxstd: '03,11,14,1z',    os: ubuntu-18.04 }
+          - { compiler: gcc-6,     cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          - { compiler: gcc-7,     cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          - { compiler: gcc-8,     cxxstd: '03,11,14,17,2a', os: ubuntu-18.04 }
+          - { compiler: gcc-9,     cxxstd: '03,11,14,17,2a', os: ubuntu-18.04 }
+          - { compiler: gcc-10,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { compiler: gcc-11,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { name: GCC w/ sanitizers, sanitize: yes,
+              compiler: gcc-11,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { name: Collect coverage, coverage: yes,
+              compiler: gcc-10,    cxxstd: '03,11',          os: ubuntu-20.04, install: 'g++-10-multilib', address-model: '32,64' }
+
+          # Linux, clang
+          - { compiler: clang-3.5, cxxstd: '03,11',          os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: clang-3.6, cxxstd: '03,11,14',       os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: clang-3.7, cxxstd: '03,11,14',       os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: clang-3.8, cxxstd: '03,11,14',       os: ubuntu-20.04, container: 'ubuntu:16.04' }
+          - { compiler: clang-3.9, cxxstd: '03,11,14',       os: ubuntu-18.04 }
+          - { compiler: clang-4.0, cxxstd: '03,11,14',       os: ubuntu-18.04 }
+          - { compiler: clang-5.0, cxxstd: '03,11,14,1z',    os: ubuntu-18.04 }
+          - { compiler: clang-6.0, cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          - { compiler: clang-7,   cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          # Note: clang-8 does not fully support C++20, so it is not compatible with some libstdc++ versions in this mode
+          - { compiler: clang-8,   cxxstd: '03,11,14,17,2a', os: ubuntu-18.04, install: 'clang-8 g++-7', gcc_toolchain: 7 }
+          - { compiler: clang-9,   cxxstd: '03,11,14,17,2a', os: ubuntu-20.04 }
+          - { compiler: clang-10,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { compiler: clang-11,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { name: Clang w/ valgrind, valgrind: yes,
+              compiler: clang-12,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04, install: 'valgrind' }
+
+          # libc++
+          - { compiler: clang-6.0, cxxstd: '03,11,14',       os: ubuntu-18.04, stdlib: libc++, install: 'clang-6.0 libc++-dev libc++abi-dev' }
+          - { compiler: clang-12,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev' }
+          - { name: Clang w/ sanitizers, sanitize: yes,
+              compiler: clang-12,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev' }
+
+          # OSX, clang
+          - { compiler: clang,     cxxstd: '03,11,14,17,2a', os: macos-10.15, sanitize: yes }
+
+          # Coverity Scan
+          # requires two github secrets in repo to activate; see ci/github/coverity.sh
+          # does not run on pull requests, only on pushes into develop and master
+          - { name: Coverity, coverity: yes,
+              compiler: clang-10,  cxxstd: '17',             os: ubuntu-20.04, ccache: no }
+
+          # multiarch (bigendian testing) - does not support coverage yet
+          - { name: Big-endian, multiarch: yes,
+              compiler: clang,     cxxstd: '17',             os: ubuntu-20.04, ccache: no, distro: fedora, edition: 34, arch: s390x }
+
+
+    timeout-minutes: 120
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+    env: {B2_USE_CCACHE: 1}
+
+    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}}" ] && [ -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
+                # Need (newer) git
+                for i in {1..${NET_RETRY_COUNT:-3}}; do sudo -E add-apt-repository -y ppa:git-core/ppa && break || sleep 10; done
+                apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+                apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y g++ python libpython-dev git
+            fi
+            # multiple job types are not compatible with ccache, they use "ccache: no" in the matrix
+            if [[ "${{ matrix.ccache }}" == "no" ]]; then
+                echo "B2_USE_CCACHE=0" >> $GITHUB_ENV
+            fi
+            if [[ "${{ matrix.valgrind }}" == "yes" ]]; then
+                echo "B2_DEFINES=BOOST_NO_STRESS_TEST=1" >> $GITHUB_ENV
+                echo "B2_TESTFLAGS=testing.launcher=valgrind" >> $GITHUB_ENV
+                echo "B2_FLAGS=define=BOOST_USE_VALGRIND=1" >> $GITHUB_ENV
+                echo "VALGRIND_OPTS=--error-exitcode=1" >> $GITHUB_ENV
+            fi
+            git config --global pack.threads 0
+
+      - uses: actions/checkout@v3
+        with:
+          # For coverage builds fetch the whole history, else only 1 commit using a 'fake ternary'
+          fetch-depth: ${{ matrix.coverage && '0' || '1' }}
+
+      - name: Cache ccache
+        uses: actions/cache@v3
+        if: env.B2_USE_CCACHE
+        with:
+          path: ~/.ccache
+          key: ${{matrix.os}}-${{matrix.container}}-${{matrix.compiler}}-${{github.sha}}
+          restore-keys: |
+            ${{matrix.os}}-${{matrix.container}}-${{matrix.compiler}}-
+            ${{matrix.os}}-${{matrix.container}}-${{matrix.compiler}}
+
+      - name: Fetch Boost.CI
+        uses: actions/checkout@v3
+        with:
+          repository: boostorg/boost-ci
+          ref: master
+          path: boost-ci-cloned
+
+      - name: Get CI scripts folder
+        run: |
+            # Copy ci folder if not testing Boost.CI
+            [[ "$GITHUB_REPOSITORY" =~ "boost-ci" ]] || cp -r boost-ci-cloned/ci .
+            rm -rf boost-ci-cloned
+
+      - name: Install packages
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+            SOURCE_KEYS=(${{join(matrix.source_keys, ' ')}})
+            SOURCES=(${{join(matrix.sources, ' ')}})
+            # Add this by default
+            SOURCES+=(ppa:ubuntu-toolchain-r/test)
+            for key in "${SOURCE_KEYS[@]}"; do
+                for i in {1..$NET_RETRY_COUNT}; do
+                    wget -O - "$key" | sudo apt-key add - && break || sleep 10
+                done
+            done
+            for source in "${SOURCES[@]}"; do
+                for i in {1..$NET_RETRY_COUNT}; do
+                    sudo add-apt-repository $source && break || sleep 10
+                done
+            done
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+            if [[ -z "${{matrix.install}}" ]]; then
+                pkgs="${{matrix.compiler}}"
+                pkgs="${pkgs/gcc-/g++-}"
+            else
+                pkgs="${{matrix.install}}"
+            fi
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y $pkgs
+
+      - 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 multiarch
+        if: matrix.multiarch
+        run: |
+          sudo apt-get install --no-install-recommends -y binfmt-support qemu-user-static
+          sudo docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+          git clone https://github.com/jeking3/bdde.git
+          echo "$(pwd)/bdde/bin/linux" >> ${GITHUB_PATH}
+          echo "BDDE_DISTRO=${{ matrix.distro }}" >> ${GITHUB_ENV}
+          echo "BDDE_EDITION=${{ matrix.edition }}" >> ${GITHUB_ENV}
+          echo "BDDE_ARCH=${{ matrix.arch }}" >> ${GITHUB_ENV}
+          echo "B2_DEFINES=BOOST_NO_STRESS_TEST=1" >> ${GITHUB_ENV}
+          echo "B2_WRAPPER=bdde" >> ${GITHUB_ENV}
+
+      - name: Setup Boost
+        env:
+          B2_ADDRESS_MODEL: ${{matrix.address-model}}
+          B2_COMPILER: ${{matrix.compiler}}
+          B2_CXXSTD: ${{matrix.cxxstd}}
+          B2_SANITIZE: ${{matrix.sanitize}}
+          B2_STDLIB: ${{matrix.stdlib}}
+        run: source ci/github/install.sh
+
+      - name: Setup coverage collection
+        if: matrix.coverage
+        run: ci/github/codecov.sh "setup"
+
+      - name: Run tests
+        if: '!matrix.coverity'
+        run: ci/build.sh
+
+      - name: Upload coverage
+        if: matrix.coverage
+        run: ci/codecov.sh "upload"
+
+      - name: Run coverity
+        if: matrix.coverity && github.event_name == 'push' && (github.ref_name == 'develop' || github.ref_name == 'master')
+        run: ci/github/coverity.sh
+        env:
+          COVERITY_SCAN_NOTIFICATION_EMAIL: ${{ secrets.COVERITY_SCAN_NOTIFICATION_EMAIL }}
+          COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
+
+  windows:
+    defaults:
+      run:
+        shell: cmd
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { toolset: msvc-14.2, cxxstd: '14,17,20',       addrmd: '32,64', os: windows-2019 }
+          - { name: Collect coverage, coverage: yes,
+              toolset: msvc-14.3, cxxstd: '14,17,20',       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: Fetch Boost.CI
+        uses: actions/checkout@v2
+        with:
+          repository: boostorg/boost-ci
+          ref: master
+          path: boost-ci-cloned
+      - name: Get CI scripts folder
+        run: |
+            REM Copy ci folder if not testing Boost.CI
+            if "%GITHUB_REPOSITORY%" == "%GITHUB_REPOSITORY:boost-ci=%" xcopy /s /e /q /i /y boost-ci-cloned\ci .\ci
+            rmdir /s /q boost-ci-cloned
+
+      - name: Setup Boost
+        run: ci\github\install.bat
+
+      - name: Run tests
+        if: '!matrix.coverage'
+        run: ci\build.bat
+        env:
+          B2_TOOLSET: ${{matrix.toolset}}
+          B2_CXXSTD: ${{matrix.cxxstd}}
+          B2_ADDRESS_MODEL: ${{matrix.addrmd}}
+
+      - name: Collect coverage
+        shell: powershell
+        if: matrix.coverage
+        run: ci\opencppcoverage.ps1
+        env:
+          B2_TOOLSET: ${{matrix.toolset}}
+          B2_CXXSTD: ${{matrix.cxxstd}}
+          B2_ADDRESS_MODEL: ${{matrix.addrmd}}
+
+      - name: Upload coverage
+        if: matrix.coverage
+        uses: codecov/codecov-action@v2
+        with:
+          files: __out/cobertura.xml
+
+  CMake:
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-20.04, build_shared: ON,  build_type: Release, generator: 'Unix Makefiles' }
+          - { os: ubuntu-20.04, build_shared: OFF, build_type: Debug, generator: 'Unix Makefiles' }
+          - { os: windows-2019, build_shared: ON,  build_type: Release, generator: 'Visual Studio 16 2019' }
+          - { os: windows-2019, build_shared: OFF, build_type: Debug, generator: 'Visual Studio 16 2019' }
+
+    timeout-minutes: 120
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Fetch Boost.CI
+        uses: actions/checkout@v2
+        with:
+          repository: boostorg/boost-ci
+          ref: master
+          path: boost-ci-cloned
+
+      - name: Get CI scripts folder
+        run: |
+            # Copy ci folder if not testing Boost.CI
+            [[ "$GITHUB_REPOSITORY" =~ "boost-ci" ]] || cp -r boost-ci-cloned/ci .
+            rm -rf boost-ci-cloned
+
+      - name: Setup Boost
+        env: {B2_DONT_BOOTSTRAP: 1}
+        run: source ci/github/install.sh
+
+      - name: Run CMake
+        run: |
+            cd "$BOOST_ROOT"
+            mkdir __build_cmake_test__ && cd __build_cmake_test__
+            cmake -G "${{matrix.generator}}" -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DBOOST_INCLUDE_LIBRARIES=$SELF -DBUILD_SHARED_LIBS=${{matrix.build_shared}} -DBUILD_TESTING=ON -DBoost_VERBOSE=ON ..
+            cmake --build . --config ${{matrix.build_type}}

.travis.yml

@@ -0,0 +1,235 @@
+# Copyright 2016 Peter Dimov
+# Copyright 2017 - 2019 James E. King III
+# 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)
+
+#
+# Generic Travis CI build script for boostorg repositories
+# See: https://github.com/boostorg/boost-ci
+#
+# Instructions for customizing this script for your library:
+#
+# 1. Customize the compilers and language levels you want in the 'jobs'.
+# 2. If you have more than include/, src/, test/, example/, examples/, or
+#    tools/ directories, modify your Travis CI project and add the environment
+#    variable DEPINST.  For example if your build uses code in "bench/" and
+#    "fog/" directories, then set DEPINST to the following:
+#        --include bench --include fog
+# 3. If you want to enable Coverity Scan, you need to provide the environment
+#    variables COVERITY_SCAN_TOKEN and COVERITY_SCAN_NOTIFICATION_EMAIL in
+#    your github settings.
+# 4. If you want to enable a big-endian build, you need to uncomment the
+#    big-endian build job.
+# 5. Enable pull request builds in your boostorg/<library> account.
+#
+# That's it - the scripts will do everything else for you.
+
+dist: xenial
+language: cpp
+
+env:
+  global:
+  # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
+  # - B2_ADDRESS_MODEL=address-model=64,32
+  # - B2_LINK=link=shared,static
+  # - B2_THREADING=threading=multi,single
+    - B2_VARIANT=variant=release
+
+install:
+  - git clone https://github.com/boostorg/boost-ci.git boost-ci
+  - cp -pr boost-ci/ci boost-ci/.codecov.yml .
+  - source ci/travis/install.sh
+
+addons:
+  apt:
+    packages:
+      - binutils-gold
+      - gdb
+      - libc6-dbg
+      - qemu-user-static
+
+services:
+  - docker
+
+branches:
+  only:
+    - master
+    - develop
+    - /bugfix\/.*/
+    - /feature\/.*/
+    - /fix\/.*/
+    - /pr\/.*/
+
+script:
+  - cd $BOOST_ROOT/libs/$SELF
+  - ci/travis/build.sh
+
+#
+# Default toolsets in Ubuntu
+#
+#       trusty xenial bionic
+#        14.04  16.04  18.04
+#       ------ ------ ------
+# clang    3.4    3.8    6.0
+#   gcc  4.8.2  5.3.1  7.3.0
+#
+
+anchors:
+  clang-38: &clang-38 { apt: { packages: [ "clang-3.8",
+                                           "libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-3.8",
+                                                                           "ubuntu-toolchain-r-test"   ] } }
+  clang-4:  &clang-4  { apt: { packages: [ "clang-4.0",
+                                           "libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-4.0",
+                                                                           "ubuntu-toolchain-r-test"   ] } }
+  clang-5:  &clang-5  { apt: { packages: [ "clang-5.0",
+                                           "libstdc++-7-dev" ], sources: [ "llvm-toolchain-xenial-5.0",
+                                                                           "ubuntu-toolchain-r-test"   ] } }
+  clang-6:  &clang-6  { apt: { packages: [ "clang-6.0",
+                                           "libc6-dbg",
+                                           "libc++-dev",
+                                           "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-6.0",
+                                                                           "ubuntu-toolchain-r-test"   ] } }
+  clang-7:  &clang-7  { apt: { packages: [ "clang-7",
+                                           "libc6-dbg",
+                                           "libc++-dev",
+                                           "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-7",
+                                                                           "ubuntu-toolchain-r-test"   ] } }
+  clang-8:  &clang-8  { apt: { packages: [ "clang-8",
+                                           "libc6-dbg",
+                                           "libc++-dev",
+                                           "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-8",
+                                                                           "ubuntu-toolchain-r-test"   ] } }
+  gcc-48:   &gcc-48   { apt: { packages: [ "g++-4.8"         ]                                           } }
+  gcc-49:   &gcc-49   { apt: { packages: [ "g++-4.9"         ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-5:    &gcc-5    { apt: { packages: [ "g++-5"           ]                                           } }
+  gcc-6:    &gcc-6    { apt: { packages: [ "g++-6"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-7:    &gcc-7    { apt: { packages: [ "g++-7"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-8:    &gcc-8    { apt: { packages: [ "g++-8"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+  gcc-9:    &gcc-9    { apt: { packages: [ "g++-9"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
+
+jobs:
+  allow_failures:
+    - env:
+      - COPY="all the environment settings from your job"
+
+  include:
+    # libstdc++
+    - { os: "linux", dist: "trusty",  # xenial has libstdc++ from gcc 5.4.0 with newer ABI
+                     env: [ "B2_TOOLSET=gcc-4.8",     "B2_CXXSTD=03,11"    ], addons: *gcc-48    }
+    - { os: "linux", dist: "trusty",  # xenial has libstdc++ from gcc 5.4.0 with newer ABI
+                     env: [ "B2_TOOLSET=gcc-4.9",     "B2_CXXSTD=03,11"    ], addons: *gcc-49    }
+    - { os: "linux", env: [ "B2_TOOLSET=gcc-5",       "B2_CXXSTD=03,11"    ], addons: *gcc-5     }
+    - { os: "linux", env: [ "B2_TOOLSET=gcc-6",       "B2_CXXSTD=11,14"    ], addons: *gcc-6     }
+    - { os: "linux", env: [ "B2_TOOLSET=gcc-7",       "B2_CXXSTD=14,17"    ], addons: *gcc-7     }
+    - { os: "linux", env: [ "B2_TOOLSET=gcc-8",       "B2_CXXSTD=17,2a"    ], addons: *gcc-8     }
+    - { os: "linux", env: [ "B2_TOOLSET=gcc-9",       "B2_CXXSTD=17,2a"    ], addons: *gcc-9     }
+    - { os: "linux", dist: "trusty",  # xenial has libstdc++ from gcc 5.4.0 with newer ABI
+                     env: [ "B2_TOOLSET=clang-3.8",   "B2_CXXSTD=03,11"    ], addons: *clang-38  }
+    - { os: "linux", env: [ "B2_TOOLSET=clang-4.0",   "B2_CXXSTD=11,14"    ], addons: *clang-4   }
+    - { os: "linux", env: [ "B2_TOOLSET=clang-5.0",   "B2_CXXSTD=11,14"    ], addons: *clang-5   }
+    - { os: "linux", env: [ "B2_TOOLSET=clang-6.0",   "B2_CXXSTD=14,17"    ], addons: *clang-6   }
+    - { os: "linux", env: [ "B2_TOOLSET=clang-7",     "B2_CXXSTD=17,2a"    ], addons: *clang-7   }
+    - { os: "linux", env: [ "B2_TOOLSET=clang-8",     "B2_CXXSTD=17,2a"    ], addons: *clang-8   }
+
+    # libc++
+    - { os: "linux", env: [ "B2_TOOLSET=clang-6.0",   "B2_CXXSTD=03,11,14",
+                            "B2_CXXFLAGS=-stdlib=libc++"                   ], addons: *clang-6   }
+    - { os: "osx"  , env: [ "B2_TOOLSET=clang",       "B2_CXXSTD=03,11,17" ]                     }
+
+    # to enable Intel ICC define INTEL_ICC_SERIAL_NUMBER and the following (under development):
+    # - { os: "linux", env: [ "B2_TOOLSET=intel-linux", "B2_CXXSTD=11,14,17" ], addons: *gcc-7,
+    #     script: cd $BOOST_ROOT/libs/$SELF && ci/travis/intelicc.sh                               }
+
+    # uncomment to enable a big-endian build job, just note that it is 5-10 times slower
+    # than a regular build and travis has a 50 minute time limit per job
+    # - os: linux
+    #   env:
+    #     - COMMENT=big-endian
+    #     - B2_CXXSTD=03
+    #     - B2_TOOLSET=gcc
+    #     - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
+    #     - BDDE_OS=red
+    #     - BDDE_ARCH=ppc64
+    #   script:
+    #     - cd $BOOST_ROOT/libs/$SELF
+    #     - ci/travis/bdde.sh
+
+    - os: linux
+      env:
+        - COMMENT=codecov.io
+        - B2_CXXSTD=03,11
+        - B2_TOOLSET=gcc-8
+        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
+      addons: *gcc-8
+      script:
+        - cd $BOOST_ROOT/libs/$SELF
+        - ci/travis/codecov.sh
+
+    - os: linux
+      env:
+        - COMMENT=asan
+        - B2_VARIANT=variant=debug
+        - B2_TOOLSET=gcc-8
+        - B2_CXXSTD=03,11,14
+        - B2_CXXFLAGS="address-sanitizer=norecover"
+        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
+      addons: *gcc-8
+
+    - os: linux
+      env:
+        - COMMENT=tsan
+        - B2_VARIANT=variant=debug
+        - B2_TOOLSET=gcc-8
+        - B2_CXXSTD=03,11,14
+        - B2_CXXFLAGS="thread-sanitizer=norecover"
+        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
+      addons: *gcc-8
+
+    - os: linux
+      env:
+        - COMMENT=ubsan
+        - B2_VARIANT=variant=debug
+        - B2_TOOLSET=gcc-8
+        - B2_CXXSTD=03,11,14
+        - B2_CXXFLAGS="undefined-sanitizer=norecover"
+        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
+        - B2_LINKFLAGS="linkflags=-fuse-ld=gold"
+        - UBSAN_OPTIONS=print_stacktrace=1
+      addons: *gcc-8
+
+    - os: linux
+      env:
+        - COMMENT=valgrind
+        - B2_TOOLSET=clang-6.0
+        - B2_CXXSTD=03,11,14
+        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
+        - B2_VARIANT=variant=debug
+        - B2_TESTFLAGS=testing.launcher=valgrind
+        - VALGRIND_OPTS=--error-exitcode=1
+      addons: *clang-6
+      script:
+        - cd $BOOST_ROOT/libs/$SELF
+        - ci/travis/valgrind.sh
+
+    # - os: linux
+    #   env:
+    #     - COMMENT=cppcheck
+    #   script:
+    #     - cd $BOOST_ROOT/libs/$SELF
+    #     - ci/travis/cppcheck.sh
+
+    #################### Jobs to run on pushes to master, develop ###################
+
+    # Coverity Scan
+    - os: linux
+      if: (env(COVERITY_SCAN_NOTIFICATION_EMAIL) IS present) AND (branch IN (develop, master)) AND (type IN (cron, push))
+      env:
+        - COMMENT="Coverity Scan"
+        - B2_TOOLSET=clang
+      script:
+        - cd $BOOST_ROOT/libs/$SELF
+        - ci/travis/coverity.sh
+
+notifications:
+  email:
+    false

CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright 2018 Mike Dev
+# 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
+
+cmake_minimum_required( VERSION 3.5...3.20 )
+project( boost_logic VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX )
+
+add_library( boost_logic INTERFACE )
+add_library( Boost::logic ALIAS boost_logic )
+
+target_include_directories( boost_logic INTERFACE include )
+
+target_link_libraries( boost_logic
+    INTERFACE
+        Boost::config
+        Boost::core
+)

Jamfile

@@ -0,0 +1,10 @@
+#  Boost.Logic Library Jamfile
+#
+#  Copyright (c) 2018 James E. King III
+#
+#  Use, modification, and distribution are subject to 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)
+
+# please order by name to ease maintenance
+build-project test ;

LICENSE

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,34 @@
+Logic, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), provides `boost::logic::tribool` for 3-state boolean logic.
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+
+### Properties
+
+* C++03
+* Header Only
+
+### Build Status
+
+Branch          | GHA CI | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
+:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
+[`master`](https://github.com/boostorg/logic/tree/master) | [![Build Status](https://github.com/boostorg/logic/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/logic/actions?query=branch:master) | [![Build status](https://ci.appveyor.com/api/projects/status/a898pj8spmo2t3x9/branch/master?svg=true)](https://ci.appveyor.com/project/jeking3/logic-vv3ct/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/16173/badge.svg)](https://scan.coverity.com/projects/boostorg-logic) | [![codecov](https://codecov.io/gh/boostorg/logic/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/logic/branch/master)| [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/logic.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/doc/html/tribool.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/logic.html)
+[`develop`](https://github.com/boostorg/logic/tree/develop) | [![Build Status](https://github.com/boostorg/logic/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/logic/actions?query=branch:develop) | [![Build status](https://ci.appveyor.com/api/projects/status/a898pj8spmo2t3x9/branch/develop?svg=true)](https://ci.appveyor.com/project/jeking3/logic-vv3ct/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/16173/badge.svg)](https://scan.coverity.com/projects/boostorg-logic) | [![codecov](https://codecov.io/gh/boostorg/logic/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/logic/branch/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/logic.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/doc/html/tribool.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/logic.html)
+
+### Directories
+
+| Name        | Purpose                        |
+| ----------- | ------------------------------ |
+| `doc`       | documentation                  |
+| `example`   | examples                       |
+| `include`   | headers                        |
+| `test`      | unit tests                     |
+
+### More information
+
+* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-logic)
+* [Report bugs](https://github.com/boostorg/logic/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[logic]` tag at the beginning of the subject line.
+

doc/Jamfile.v2

@@ -1,3 +1,13 @@
+# Tribool library
+
+# Copyright (C) 2002-2003 Douglas Gregor
+
+# Use, modification and distribution is subject to 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)
+
+# For more information, see http://www.boost.org/
+
 project boost-sandbox/utility/doc ;
 import boostbook ;
 import doxygen ;
@@ -14,3 +24,13 @@ boostbook tribool
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
         <dependency>reference
     ;
+
+###############################################################################
+alias boostdoc
+    : tribool/<format>docbook
+    :
+    :
+    : ;
+explicit boostdoc ;
+alias boostrelease ;
+explicit boostrelease ;

doc/tribool.boostbook

@@ -138,6 +138,18 @@ if (<functionname>indeterminate</functionname>(x)) {
 else {
   // report success or failure of x
 }</programlisting>
+
+  <para> All the logical operators and methods of <code><classname>tribool</classname></code> are marked
+  as <code>constexpr</code> in C++11. It means that <code><classname>tribool</classname></code> can
+  be used in compile time expressions:</para>
+
+  <programlisting>constexpr <classname>tribool</classname> x = (tribool(true) || tribool(indeterminate));
+<functionname>static_assert</functionname>(x, "Must be true!");
+</programlisting>
+
+  <note>Some compilers may have troubles with evaluating <code>tribool::operator safe_bool()</code> at compile time.</note>
+
+
 </section>
   
   <section>

include/boost/logic/tribool.hpp

@@ -14,7 +14,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
+#ifdef BOOST_HAS_PRAGMA_ONCE
 #  pragma once
 #endif
 
@@ -30,7 +30,7 @@ namespace detail {
  */
 struct indeterminate_t
 {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x0600)
+#if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x0600)
   char dummy_; // BCB would use 8 bytes by default
 #endif
 };
@@ -59,9 +59,9 @@ typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);
  * \returns <tt>x.value == tribool::indeterminate_value</tt>
  * \throws nothrow
  */
-inline bool
+BOOST_CONSTEXPR inline bool
 indeterminate(tribool x,
-              detail::indeterminate_t dummy = detail::indeterminate_t());
+              detail::indeterminate_t dummy = detail::indeterminate_t()) BOOST_NOEXCEPT;
 
 /**
  * \brief A 3-state boolean type.
@@ -71,6 +71,7 @@ indeterminate(tribool x,
  */
 class tribool
 {
+#if defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
 private:
   /// INTERNAL ONLY
   struct dummy {
@@ -78,6 +79,7 @@ private:
   };
 
   typedef void (dummy::*safe_bool)();
+#endif
 
 public:
   /**
@@ -85,7 +87,7 @@ public:
    *
    * \throws nothrow
    */
-  tribool() : value(false_value) {}
+  BOOST_CONSTEXPR tribool() BOOST_NOEXCEPT : value(false_value) {}
 
   /**
    * Construct a new 3-state boolean value with the given boolean
@@ -93,14 +95,14 @@ public:
    *
    * \throws nothrow
    */
-  tribool(bool initial_value) : value(initial_value? true_value : false_value) {}
+  BOOST_CONSTEXPR tribool(bool initial_value) BOOST_NOEXCEPT : value(initial_value? true_value : false_value) {}
 
   /**
    * Construct a new 3-state boolean value with an indeterminate value.
    *
    * \throws nothrow
    */
-  tribool(indeterminate_keyword_t) : value(indeterminate_value) {}
+  BOOST_CONSTEXPR tribool(indeterminate_keyword_t) BOOST_NOEXCEPT : value(indeterminate_value) {}
 
   /**
    * Use a 3-state boolean in a boolean context. Will evaluate true in a
@@ -109,11 +111,22 @@ public:
    * \returns true if the 3-state boolean is true, false otherwise
    * \throws nothrow
    */
-  operator safe_bool() const
+#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
+
+  BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT
+  {
+    return value == true_value;
+  }
+
+#else
+
+  BOOST_CONSTEXPR operator safe_bool() const BOOST_NOEXCEPT
   {
     return value == true_value? &dummy::nonnull : 0;
   }
 
+#endif
+
   /**
    * The actual stored value in this 3-state boolean, which may be false, true,
    * or indeterminate.
@@ -123,7 +136,7 @@ public:
 
 // Check if the given tribool has an indeterminate value. Also doubles as a
 // keyword for the 'indeterminate' value
-inline bool indeterminate(tribool x, detail::indeterminate_t)
+BOOST_CONSTEXPR inline bool indeterminate(tribool x, detail::indeterminate_t) BOOST_NOEXCEPT
 {
   return x.value == tribool::indeterminate_value;
 }
@@ -156,7 +169,7 @@ inline bool indeterminate(tribool x, detail::indeterminate_t)
  *  </table>
  * \throws nothrow
  */
-inline tribool operator!(tribool x)
+BOOST_CONSTEXPR inline tribool operator!(tribool x) BOOST_NOEXCEPT
 {
   return x.value == tribool::false_value? tribool(true)
         :x.value == tribool::true_value? tribool(false)
@@ -164,7 +177,7 @@ inline tribool operator!(tribool x)
 }
 
 /**
- * \brief Computes the logical conjuction of two tribools
+ * \brief Computes the logical conjunction of two tribools
  *
  * \returns the result of logically ANDing the two tribool values,
  * according to the following table:
@@ -196,38 +209,36 @@ inline tribool operator!(tribool x)
  *       </table>
  * \throws nothrow
  */
-inline tribool operator&&(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator&&(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (static_cast<bool>(!x) || static_cast<bool>(!y))
-    return false;
-  else if (static_cast<bool>(x) && static_cast<bool>(y))
-    return true;
-  else
-    return indeterminate;
+  return (static_cast<bool>(!x) || static_cast<bool>(!y))
+    ? tribool(false)
+    : ((static_cast<bool>(x) && static_cast<bool>(y)) ? tribool(true) : indeterminate)
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator&&(tribool x, bool y)
+BOOST_CONSTEXPR inline tribool operator&&(tribool x, bool y) BOOST_NOEXCEPT
 { return y? x : tribool(false); }
 
 /**
  * \overload
  */
-inline tribool operator&&(bool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator&&(bool x, tribool y) BOOST_NOEXCEPT
 { return x? y : tribool(false); }
 
 /**
  * \overload
  */
-inline tribool operator&&(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator&&(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return !x? tribool(false) : tribool(indeterminate); }
 
 /**
  * \overload
  */
-inline tribool operator&&(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator&&(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return !x? tribool(false) : tribool(indeterminate); }
 
 /**
@@ -263,38 +274,36 @@ inline tribool operator&&(tribool x, indeterminate_keyword_t)
  *       </table>
  *  \throws nothrow
  */
-inline tribool operator||(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator||(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (static_cast<bool>(!x) && static_cast<bool>(!y))
-    return false;
-  else if (static_cast<bool>(x) || static_cast<bool>(y))
-    return true;
-  else
-    return indeterminate;
+  return (static_cast<bool>(!x) && static_cast<bool>(!y))
+    ? tribool(false)
+    : ((static_cast<bool>(x) || static_cast<bool>(y)) ? tribool(true) : tribool(indeterminate))
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator||(tribool x, bool y)
+BOOST_CONSTEXPR inline tribool operator||(tribool x, bool y) BOOST_NOEXCEPT
 { return y? tribool(true) : x; }
 
 /**
  * \overload
  */
-inline tribool operator||(bool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator||(bool x, tribool y) BOOST_NOEXCEPT
 { return x? tribool(true) : y; }
 
 /**
  * \overload
  */
-inline tribool operator||(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator||(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return x? tribool(true) : tribool(indeterminate); }
 
 /**
  * \overload
  */
-inline tribool operator||(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator||(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return x? tribool(true) : tribool(indeterminate); }
 //@}
 
@@ -331,34 +340,34 @@ inline tribool operator||(tribool x, indeterminate_keyword_t)
  *      </table>
  * \throws nothrow
  */
-inline tribool operator==(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator==(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (indeterminate(x) || indeterminate(y))
-    return indeterminate;
-  else
-    return (x && y) || (!x && !y);
+  return (indeterminate(x) || indeterminate(y))
+    ? indeterminate
+    : ((x && y) || (!x && !y))
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator==(tribool x, bool y) { return x == tribool(y); }
+BOOST_CONSTEXPR inline tribool operator==(tribool x, bool y) BOOST_NOEXCEPT { return x == tribool(y); }
 
 /**
  * \overload
  */
-inline tribool operator==(bool x, tribool y) { return tribool(x) == y; }
+BOOST_CONSTEXPR inline tribool operator==(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) == y; }
 
 /**
  * \overload
  */
-inline tribool operator==(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator==(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return tribool(indeterminate) == x; }
 
 /**
  * \overload
  */
-inline tribool operator==(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator==(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return tribool(indeterminate) == x; }
 
 /**
@@ -394,34 +403,34 @@ inline tribool operator==(tribool x, indeterminate_keyword_t)
  *       </table>
  * \throws nothrow
  */
-inline tribool operator!=(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator!=(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (indeterminate(x) || indeterminate(y))
-    return indeterminate;
-  else
-    return !((x && y) || (!x && !y));
+  return (indeterminate(x) || indeterminate(y))
+    ? indeterminate
+    : !((x && y) || (!x && !y))
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator!=(tribool x, bool y) { return x != tribool(y); }
+BOOST_CONSTEXPR inline tribool operator!=(tribool x, bool y) BOOST_NOEXCEPT { return x != tribool(y); }
 
 /**
  * \overload
  */
-inline tribool operator!=(bool x, tribool y) { return tribool(x) != y; }
+BOOST_CONSTEXPR inline tribool operator!=(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) != y; }
 
 /**
  * \overload
  */
-inline tribool operator!=(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator!=(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return tribool(indeterminate) != x; }
 
 /**
  * \overload
  */
-inline tribool operator!=(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator!=(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return x != tribool(indeterminate); }
 
 } } // end namespace boost::logic

include/boost/logic/tribool_io.hpp

@@ -11,7 +11,7 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/noncopyable.hpp>
 
-#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -45,7 +45,7 @@ template<>
 inline std::basic_string<char> default_false_name<char>()
 { return "false"; }
 
-#  ifndef BOOST_NO_WCHAR_T
+#  if !defined(BOOST_NO_CWCHAR)
 /**
  * \brief Returns the wide character string L"false".
  *
@@ -76,7 +76,7 @@ template<>
 inline std::basic_string<char> default_true_name<char>()
 { return "true"; }
 
-#  ifndef BOOST_NO_WCHAR_T
+#  if !defined(BOOST_NO_CWCHAR)
 /**
  * \brief Returns the wide character string L"true".
  *
@@ -104,17 +104,11 @@ template<>
 inline std::basic_string<char> get_default_indeterminate_name<char>()
 { return "indeterminate"; }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// VC++ 6.0 chokes on the specialization below, so we're stuck without 
-// wchar_t support. What a pain. TODO: it might just need a the template 
-// parameter as function parameter...
-#else
-#  ifndef BOOST_NO_WCHAR_T
+#if !defined(BOOST_NO_CWCHAR)
 /// Returns the wide character string L"indeterminate".
 template<>
 inline std::basic_string<wchar_t> get_default_indeterminate_name<wchar_t>()
 { return L"indeterminate"; }
-#  endif
 #endif
 
 // http://www.cantrip.org/locale.html
@@ -285,9 +279,9 @@ operator>>(std::basic_istream<CharT, Traits>& in, tribool& x)
       bool falsename_ok = true, truename_ok = true, othername_ok = true;
 
       // Modeled after the code from Library DR 17
-      while (falsename_ok && pos < falsename.size()
-             || truename_ok && pos < truename.size()
-             || othername_ok && pos < othername.size()) {
+      while ((falsename_ok && pos < falsename.size())
+             || (truename_ok && pos < truename.size())
+             || (othername_ok && pos < othername.size())) {
         typename Traits::int_type c = in.get();
         if (c == Traits::eof())
           return in;

meta/libraries.json

@@ -0,0 +1,16 @@
+{
+    "key": "logic/tribool",
+    "name": "Tribool",
+    "authors": [
+        "Doug Gregor"
+    ],
+    "description": "3-state boolean type library.",
+    "documentation": "/doc/html/tribool.html",
+    "category": [
+        "Miscellaneous"
+    ],
+    "maintainers": [
+        "Douglas Gregor <dgregor -at- cs.indiana.edu>"
+    ],
+    "cxxstd": "03"
+}

test/Jamfile.v2

@@ -8,10 +8,55 @@
 
 # For more information, see http://www.boost.org/
 
+import path ;
+import os ;
+import regex ;
+import testing ;
+
+local self = logic ;
+
+rule test-expected-failures
+{
+    local all_rules = ;
+    local file ;
+    local tests_path = [ path.make $(BOOST_ROOT)/libs/$(self)/test/compile-fail ] ;
+    for file in [ path.glob-tree $(tests_path) : *.cpp ]
+    {
+        local rel_file = [ path.relative-to $(tests_path) $(file) ] ;
+        local test_name = [ regex.replace [ regex.replace $(rel_file) "/" "-" ] ".cpp" "" ] ;
+        local decl_test_name = cf-$(test_name) ;
+        # ECHO $(rel_file) ;
+        all_rules += [ compile-fail $(file) : : $(decl_test_name) ] ;
+    }
+
+    # ECHO All rules: $(all_rules) ;
+    return $(all_rules) ;
+}
+
+rule test-header-isolation
+{
+    local all_rules = ;
+    local file ;
+    local headers_path = [ path.make $(BOOST_ROOT)/libs/$(self)/include ] ;
+    for file in [ path.glob-tree $(headers_path) : *.hpp ]
+    {
+        local rel_file = [ path.relative-to $(headers_path) $(file) ] ;
+        # Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end.
+        #       All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes.
+        local test_name = [ regex.replace $(rel_file) "/" "-" ] ;
+        local decl_test_name = ~hdr-decl-$(test_name) ;
+        # ECHO $(rel_file) ;
+        all_rules += [ compile compile/decl_header.cpp : <define>"BOOST_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(decl_test_name) ] ;
+    }
+
+    # ECHO All rules: $(all_rules) ;
+    return $(all_rules) ;
+}
+
   test-suite logic  : 
+    [ test-expected-failures ]
+    [ test-header-isolation ]
     [ run tribool_test.cpp ]
     [ run tribool_rename_test.cpp ]
     [ run tribool_io_test.cpp ]
    ;
-
-      

test/compile-fail/implicit.cpp

@@ -0,0 +1,23 @@
+// Copyright 2018 James E. King III. Use, modification and
+// distribution is subject to 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/logic/tribool.hpp>
+
+int main(int, char*[])
+{
+  using boost::logic::indeterminate;
+  using boost::logic::tribool;
+
+  tribool i(indeterminate);
+
+#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
+  bool b = i; // expect to see: no viable conversion from 'boost::logic::tribool' to 'bool'
+  return (int)b;
+#else
+#error in c++03 explicit conversions are allowed
+#endif
+  // NOTREACHED
+  return 0;
+}

test/compile-fail/implicit_int_1.cpp

@@ -0,0 +1,16 @@
+// Copyright 2018 James E. King III. Use, modification and
+// distribution is subject to 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/logic/tribool.hpp>
+
+int main(int, char*[])
+{
+  using boost::logic::indeterminate;
+  using boost::logic::tribool;
+
+  tribool i(indeterminate);
+
+  return i; // expect to see: error: no viable conversion from returned value of type 'boost::logic::tribool' to function return type 'int'
+}

test/compile-fail/implicit_int_2.cpp

@@ -0,0 +1,16 @@
+// Copyright 2018 James E. King III. Use, modification and
+// distribution is subject to 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/logic/tribool.hpp>
+
+int main(int, char*[])
+{
+  using boost::logic::indeterminate;
+  using boost::logic::tribool;
+
+  tribool i(indeterminate);
+
+  return i + 1; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'int')
+}

test/compile-fail/implicit_int_3.cpp

@@ -0,0 +1,16 @@
+// Copyright 2018 James E. King III. Use, modification and
+// distribution is subject to 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/logic/tribool.hpp>
+
+int main(int, char*[])
+{
+  using boost::logic::indeterminate;
+  using boost::logic::tribool;
+
+  tribool i(indeterminate);
+
+  return i << 1; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'int')
+}

test/compile-fail/operator_less_1.cpp

@@ -0,0 +1,16 @@
+// Copyright 2018 James E. King III. Use, modification and
+// distribution is subject to 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/logic/tribool.hpp>
+
+int main(int, char*[])
+{
+  using boost::logic::tribool;
+
+  tribool f;       // false
+  tribool t(true); // true
+
+  return f < t; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'boost::logic::tribool')
+}

test/compile-fail/operator_less_2.cpp

@@ -0,0 +1,15 @@
+// Copyright 2018 James E. King III. Use, modification and
+// distribution is subject to 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/logic/tribool.hpp>
+
+int main(int, char*[])
+{
+  using boost::logic::tribool;
+
+  tribool t(true);
+
+  return t < 1; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'int')
+}

test/compile/decl_header.cpp

@@ -0,0 +1,24 @@
+/*
+ *             Copyright Andrey Semashev 2015.
+ * 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)
+ */
+/*!
+ * \file   decl_header.cpp
+ * \author Andrey Semashev
+ * \date   21.06.2015
+ *
+ * \brief  This file contains a test boilerplate for checking that every
+ *         public header is self-contained and does not have any missing
+ *         #includes.
+ */
+
+#define BOOST_TEST_INCLUDE_HEADER() <BOOST_TEST_HEADER>
+
+#include BOOST_TEST_INCLUDE_HEADER()
+
+int main(int, char*[])
+{
+    return 0;
+}

test/tribool_io_test.cpp

@@ -4,7 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/logic/tribool.hpp>
 #include <boost/logic/tribool_io.hpp>
-#include <boost/test/minimal.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <sstream>
 #include <string>
 #include <iostream>
@@ -14,12 +14,24 @@
 #  include <locale>
 #endif
 
-int test_main(int, char*[])
+int main()
 {
   using namespace boost::logic;
 
   tribool x;
 
+  #if !defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_STD_WSTRING)
+  std::wostringstream wout;
+  wout << std::boolalpha << tribool(false);
+  BOOST_TEST(wout.str() == L"false");
+  wout.str(std::wstring());
+  wout << std::boolalpha << tribool(true);
+  BOOST_TEST(wout.str() == L"true");
+  wout.str(std::wstring());
+  wout << std::boolalpha << tribool(indeterminate);
+  BOOST_TEST(wout.str() == L"indeterminate");
+  #endif
+
   // Check tribool output
   std::ostringstream out;
 
@@ -28,14 +40,14 @@ int test_main(int, char*[])
   x = false;
   out << x;
   std::cout << "Output false (noboolalpha): " << out.str() << std::endl;
-  BOOST_CHECK(out.str() == "0");
+  BOOST_TEST(out.str() == "0");
 
   // Output true (noboolalpha)
   out.str(std::string());
   x = true;
   out << x;
   std::cout << "Output true (noboolalpha): " << out.str() << std::endl;
-  BOOST_CHECK(out.str() == "1");
+  BOOST_TEST(out.str() == "1");
 
   // Output indeterminate (noboolalpha)
   out.str(std::string());
@@ -43,14 +55,14 @@ int test_main(int, char*[])
   out << x;
   std::cout << "Output indeterminate (noboolalpha): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "2");
+  BOOST_TEST(out.str() == "2");
 
   // Output indeterminate (noboolalpha)
   out.str(std::string());
   out << indeterminate;
   std::cout << "Output indeterminate (noboolalpha): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "2");
+  BOOST_TEST(out.str() == "2");
 
 #ifndef BOOST_NO_STD_LOCALE
   const std::numpunct<char>& punct =
@@ -61,7 +73,7 @@ int test_main(int, char*[])
   x = false;
   out << std::boolalpha << x;
   std::cout << "Output false (boolalpha): " << out.str() << std::endl;
-  BOOST_CHECK(out.str() == punct.falsename());
+  BOOST_TEST(out.str() == punct.falsename());
 
   // Output true (boolalpha)
   out.str(std::string());
@@ -69,7 +81,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output true (boolalpha): " << out.str() << std::endl;
 
-  BOOST_CHECK(out.str() == punct.truename());
+  BOOST_TEST(out.str() == punct.truename());
 
   // Output indeterminate (boolalpha - default name)
   out.str(std::string());
@@ -77,14 +89,14 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "indeterminate");
+  BOOST_TEST(out.str() == "indeterminate");
 
   // Output indeterminate (boolalpha - default name)
   out.str(std::string());
   out << std::boolalpha << indeterminate;
   std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "indeterminate");
+  BOOST_TEST(out.str() == "indeterminate");
 
 #  if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
   // No template constructors, so we can't build the test locale
@@ -97,7 +109,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output indeterminate (boolalpha - \"maybe\"): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "maybe");
+  BOOST_TEST(out.str() == "maybe");
 #  endif
 #endif // ! BOOST_NO_STD_LOCALE
 
@@ -108,7 +120,7 @@ int test_main(int, char*[])
     std::istringstream in("0");
     std::cout << "Input \"0\" (checks for false)" << std::endl;
     in >> x;
-    BOOST_CHECK(x == false);
+    BOOST_TEST(x == false);
   }
 
   // Input true (noboolalpha)
@@ -116,7 +128,7 @@ int test_main(int, char*[])
     std::istringstream in("1");
     std::cout << "Input \"1\" (checks for true)" << std::endl;
     in >> x;
-    BOOST_CHECK(x == true);
+    BOOST_TEST(x == true);
   }
 
   // Input false (noboolalpha)
@@ -124,14 +136,14 @@ int test_main(int, char*[])
     std::istringstream in("2");
     std::cout << "Input \"2\" (checks for indeterminate)" << std::endl;
     in >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 
   // Input bad number (noboolalpha)
   {
     std::istringstream in("3");
     std::cout << "Input \"3\" (checks for failure)" << std::endl;
-    BOOST_CHECK(!(in >> x));
+    BOOST_TEST(!(in >> x));
   }
 
   // Input false (boolalpha)
@@ -139,7 +151,7 @@ int test_main(int, char*[])
     std::istringstream in("false");
     std::cout << "Input \"false\" (checks for false)" << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(x == false);
+    BOOST_TEST(x == false);
   }
 
   // Input true (boolalpha)
@@ -147,7 +159,7 @@ int test_main(int, char*[])
     std::istringstream in("true");
     std::cout << "Input \"true\" (checks for true)" << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(x == true);
+    BOOST_TEST(x == true);
   }
 
   // Input indeterminate (boolalpha)
@@ -156,7 +168,7 @@ int test_main(int, char*[])
     std::cout << "Input \"indeterminate\" (checks for indeterminate)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 
   // Input bad string (boolalpha)
@@ -164,7 +176,7 @@ int test_main(int, char*[])
     std::istringstream in("bad");
     std::cout << "Input \"bad\" (checks for failure)"
               << std::endl;
-    BOOST_CHECK(!(in >> std::boolalpha >> x));
+    BOOST_TEST(!(in >> std::boolalpha >> x));
   }
 
 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
@@ -178,7 +190,7 @@ int test_main(int, char*[])
     std::cout << "Input \"maybe\" (checks for indeterminate, uses locales)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 
   // Input indeterminate named "true_or_false" (boolalpha)
@@ -190,9 +202,9 @@ int test_main(int, char*[])
     std::cout << "Input \"true_or_false\" (checks for indeterminate)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 #endif
 
-  return 0;
+  return boost::report_errors();
 }

test/tribool_rename_test.cpp

@@ -6,12 +6,12 @@
 // For more information, see http://www.boost.org
 
 #include <boost/logic/tribool.hpp>
-#include <boost/test/minimal.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 
 BOOST_TRIBOOL_THIRD_STATE(maybe)
 
-int test_main(int,char*[])
+int main()
 {
   using namespace boost::logic;
 
@@ -19,105 +19,104 @@ int test_main(int,char*[])
   tribool y(true); // true
   tribool z(maybe); // maybe
 
-  BOOST_CHECK(!x);
-  BOOST_CHECK(x == false);
-  BOOST_CHECK(false == x);
-  BOOST_CHECK(x != true);
-  BOOST_CHECK(true != x);
-  BOOST_CHECK(maybe(x == maybe));
-  BOOST_CHECK(maybe(maybe == x));
-  BOOST_CHECK(maybe(x != maybe));
-  BOOST_CHECK(maybe(maybe != x));
-  BOOST_CHECK(x == x);
-  BOOST_CHECK(!(x != x));
-  BOOST_CHECK(!(x && true));
-  BOOST_CHECK(!(true && x));
-  BOOST_CHECK(x || true);
-  BOOST_CHECK(true || x);
+  BOOST_TEST(!x);
+  BOOST_TEST(x == false);
+  BOOST_TEST(false == x);
+  BOOST_TEST(x != true);
+  BOOST_TEST(true != x);
+  BOOST_TEST(maybe(x == maybe));
+  BOOST_TEST(maybe(maybe == x));
+  BOOST_TEST(maybe(x != maybe));
+  BOOST_TEST(maybe(maybe != x));
+  BOOST_TEST(x == x);
+  BOOST_TEST(!(x != x));
+  BOOST_TEST(!(x && true));
+  BOOST_TEST(!(true && x));
+  BOOST_TEST(x || true);
+  BOOST_TEST(true || x);
 
-  BOOST_CHECK(y);
-  BOOST_CHECK(y == true);
-  BOOST_CHECK(true == y);
-  BOOST_CHECK(y != false);
-  BOOST_CHECK(false != y);
-  BOOST_CHECK(maybe(y == maybe));
-  BOOST_CHECK(maybe(maybe == y));
-  BOOST_CHECK(maybe(y != maybe));
-  BOOST_CHECK(maybe(maybe != y));
-  BOOST_CHECK(y == y);
-  BOOST_CHECK(!(y != y));
+  BOOST_TEST(y);
+  BOOST_TEST(y == true);
+  BOOST_TEST(true == y);
+  BOOST_TEST(y != false);
+  BOOST_TEST(false != y);
+  BOOST_TEST(maybe(y == maybe));
+  BOOST_TEST(maybe(maybe == y));
+  BOOST_TEST(maybe(y != maybe));
+  BOOST_TEST(maybe(maybe != y));
+  BOOST_TEST(y == y);
+  BOOST_TEST(!(y != y));
 
-  BOOST_CHECK(maybe(z || !z));
-  BOOST_CHECK(maybe(z == true));
-  BOOST_CHECK(maybe(true == z));
-  BOOST_CHECK(maybe(z == false));
-  BOOST_CHECK(maybe(false == z));
-  BOOST_CHECK(maybe(z == maybe));
-  BOOST_CHECK(maybe(maybe == z));
-  BOOST_CHECK(maybe(z != maybe));
-  BOOST_CHECK(maybe(maybe != z));
-  BOOST_CHECK(maybe(z == z));
-  BOOST_CHECK(maybe(z != z));
+  BOOST_TEST(maybe(z || !z));
+  BOOST_TEST(maybe(z == true));
+  BOOST_TEST(maybe(true == z));
+  BOOST_TEST(maybe(z == false));
+  BOOST_TEST(maybe(false == z));
+  BOOST_TEST(maybe(z == maybe));
+  BOOST_TEST(maybe(maybe == z));
+  BOOST_TEST(maybe(z != maybe));
+  BOOST_TEST(maybe(maybe != z));
+  BOOST_TEST(maybe(z == z));
+  BOOST_TEST(maybe(z != z));
 
-  BOOST_CHECK(!(x == y));
-  BOOST_CHECK(x != y);
-  BOOST_CHECK(maybe(x == z));
-  BOOST_CHECK(maybe(x != z));
-  BOOST_CHECK(maybe(y == z));
-  BOOST_CHECK(maybe(y != z));
+  BOOST_TEST(!(x == y));
+  BOOST_TEST(x != y);
+  BOOST_TEST(maybe(x == z));
+  BOOST_TEST(maybe(x != z));
+  BOOST_TEST(maybe(y == z));
+  BOOST_TEST(maybe(y != z));
 
-  BOOST_CHECK(!(x && y));
-  BOOST_CHECK(x || y);
-  BOOST_CHECK(!(x && z));
-  BOOST_CHECK(maybe(y && z));
-  BOOST_CHECK(maybe(z && z));
-  BOOST_CHECK(maybe(z || z));
-  BOOST_CHECK(maybe(x || z));
-  BOOST_CHECK(y || z);
+  BOOST_TEST(!(x && y));
+  BOOST_TEST(x || y);
+  BOOST_TEST(!(x && z));
+  BOOST_TEST(maybe(y && z));
+  BOOST_TEST(maybe(z && z));
+  BOOST_TEST(maybe(z || z));
+  BOOST_TEST(maybe(x || z));
+  BOOST_TEST(y || z);
 
-  BOOST_CHECK(maybe(y && maybe));
-  BOOST_CHECK(maybe(maybe && y));
-  BOOST_CHECK(!(x && maybe));
-  BOOST_CHECK(!(maybe && x));
+  BOOST_TEST(maybe(y && maybe));
+  BOOST_TEST(maybe(maybe && y));
+  BOOST_TEST(!(x && maybe));
+  BOOST_TEST(!(maybe && x));
 
-  BOOST_CHECK(maybe || y);
-  BOOST_CHECK(y || maybe);
-  BOOST_CHECK(maybe(x || maybe));
-  BOOST_CHECK(maybe(maybe || x));
+  BOOST_TEST(maybe || y);
+  BOOST_TEST(y || maybe);
+  BOOST_TEST(maybe(x || maybe));
+  BOOST_TEST(maybe(maybe || x));
 
   // Test the if (z) ... else (!z) ... else ... idiom
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
 
   z = true;
   if (z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
   z = false;
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
-  std::cout << "no errors detected\n";
-  return 0;
+  return boost::report_errors();
 }

test/tribool_test.cpp

@@ -3,11 +3,13 @@
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/config.hpp>
 #include <boost/logic/tribool.hpp>
-#include <boost/test/minimal.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
 #include <iostream>
 
-int test_main(int, char*[])
+int main()
 {
   using namespace boost::logic;
 
@@ -15,105 +17,138 @@ int test_main(int, char*[])
   tribool y(true); // true
   tribool z(indeterminate); // indeterminate
 
-  BOOST_CHECK(!x);
-  BOOST_CHECK(x == false);
-  BOOST_CHECK(false == x);
-  BOOST_CHECK(x != true);
-  BOOST_CHECK(true != x);
-  BOOST_CHECK(indeterminate(x == indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate == x));
-  BOOST_CHECK(indeterminate(x != indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate != x));
-  BOOST_CHECK(x == x);
-  BOOST_CHECK(!(x != x));
-  BOOST_CHECK(!(x && true));
-  BOOST_CHECK(!(true && x));
-  BOOST_CHECK(x || true);
-  BOOST_CHECK(true || x);
+#if defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
+  // c++03 allows for implicit conversion to bool
+  // c++11 uses an explicit conversion operator so this would not compile
+  //       and that is tested in the compile-fail/implicit.cpp file
+  // so we check the conversion to ensure it is sane
+  bool bx = x;
+  BOOST_TEST(bx == false);
+  bool by = y;
+  BOOST_TEST(by == true);
+  bool bz = z;
+  BOOST_TEST(bz == false);
+#endif
 
-  BOOST_CHECK(y);
-  BOOST_CHECK(y == true);
-  BOOST_CHECK(true == y);
-  BOOST_CHECK(y != false);
-  BOOST_CHECK(false != y);
-  BOOST_CHECK(indeterminate(y == indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate == y));
-  BOOST_CHECK(indeterminate(y != indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate != y));
-  BOOST_CHECK(y == y);
-  BOOST_CHECK(!(y != y));
+  BOOST_TEST(!x);
+  BOOST_TEST(x == false);
+  BOOST_TEST(false == x);
+  BOOST_TEST(x != true);
+  BOOST_TEST(true != x);
+  BOOST_TEST(indeterminate(x == indeterminate));
+  BOOST_TEST(indeterminate(indeterminate == x));
+  BOOST_TEST(indeterminate(x != indeterminate));
+  BOOST_TEST(indeterminate(indeterminate != x));
+  BOOST_TEST(x == x);
+  BOOST_TEST(!(x != x));
+  BOOST_TEST(!(x && true));
+  BOOST_TEST(!(true && x));
+  BOOST_TEST(x || true);
+  BOOST_TEST(true || x);
 
-  BOOST_CHECK(indeterminate(z || !z));
-  BOOST_CHECK(indeterminate(z == true));
-  BOOST_CHECK(indeterminate(true == z));
-  BOOST_CHECK(indeterminate(z == false));
-  BOOST_CHECK(indeterminate(false == z));
-  BOOST_CHECK(indeterminate(z == indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate == z));
-  BOOST_CHECK(indeterminate(z != indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate != z));
-  BOOST_CHECK(indeterminate(z == z));
-  BOOST_CHECK(indeterminate(z != z));
+  BOOST_TEST(y);
+  BOOST_TEST(y == true);
+  BOOST_TEST(true == y);
+  BOOST_TEST(y != false);
+  BOOST_TEST(false != y);
+  BOOST_TEST(indeterminate(y == indeterminate));
+  BOOST_TEST(indeterminate(indeterminate == y));
+  BOOST_TEST(indeterminate(y != indeterminate));
+  BOOST_TEST(indeterminate(indeterminate != y));
+  BOOST_TEST(y == y);
+  BOOST_TEST(!(y != y));
 
-  BOOST_CHECK(!(x == y));
-  BOOST_CHECK(x != y);
-  BOOST_CHECK(indeterminate(x == z));
-  BOOST_CHECK(indeterminate(x != z));
-  BOOST_CHECK(indeterminate(y == z));
-  BOOST_CHECK(indeterminate(y != z));
+  BOOST_TEST(indeterminate(z || !z));
+  BOOST_TEST(indeterminate(z == true));
+  BOOST_TEST(indeterminate(true == z));
+  BOOST_TEST(indeterminate(z == false));
+  BOOST_TEST(indeterminate(false == z));
+  BOOST_TEST(indeterminate(z == indeterminate));
+  BOOST_TEST(indeterminate(indeterminate == z));
+  BOOST_TEST(indeterminate(z != indeterminate));
+  BOOST_TEST(indeterminate(indeterminate != z));
+  BOOST_TEST(indeterminate(z == z));
+  BOOST_TEST(indeterminate(z != z));
 
-  BOOST_CHECK(!(x && y));
-  BOOST_CHECK(x || y);
-  BOOST_CHECK(!(x && z));
-  BOOST_CHECK(indeterminate(y && z));
-  BOOST_CHECK(indeterminate(z && z));
-  BOOST_CHECK(indeterminate(z || z));
-  BOOST_CHECK(indeterminate(x || z));
-  BOOST_CHECK(y || z);
+  BOOST_TEST(!(x == y));
+  BOOST_TEST(x != y);
+  BOOST_TEST(indeterminate(x == z));
+  BOOST_TEST(indeterminate(x != z));
+  BOOST_TEST(indeterminate(y == z));
+  BOOST_TEST(indeterminate(y != z));
 
-  BOOST_CHECK(indeterminate(y && indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate && y));
-  BOOST_CHECK(!(x && indeterminate));
-  BOOST_CHECK(!(indeterminate && x));
+  BOOST_TEST(!(x && y));
+  BOOST_TEST(x || y);
+  BOOST_TEST(!(x && z));
+  BOOST_TEST(indeterminate(y && z));
+  BOOST_TEST(indeterminate(z && z));
+  BOOST_TEST(indeterminate(z || z));
+  BOOST_TEST(indeterminate(x || z));
+  BOOST_TEST(y || z);
 
-  BOOST_CHECK(indeterminate || y);
-  BOOST_CHECK(y || indeterminate);
-  BOOST_CHECK(indeterminate(x || indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate || x));
+  BOOST_TEST(indeterminate(y && indeterminate));
+  BOOST_TEST(indeterminate(indeterminate && y));
+  BOOST_TEST(!(x && indeterminate));
+  BOOST_TEST(!(indeterminate && x));
+
+  BOOST_TEST(indeterminate || y);
+  BOOST_TEST(y || indeterminate);
+  BOOST_TEST(indeterminate(x || indeterminate));
+  BOOST_TEST(indeterminate(indeterminate || x));
 
   // Test the if (z) ... else (!z) ... else ... idiom
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
 
   z = true;
   if (z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
   z = false;
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
-  std::cout << "no errors detected\n";
-  return 0;
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) 
+  constexpr bool res_ors = indeterminate(false || tribool(false) || false || indeterminate); // true
+  BOOST_TEST(res_ors);
+  char array_ors[res_ors ? 2 : 3];
+  BOOST_TEST(sizeof(array_ors) / sizeof(char) == 2);
+
+  constexpr bool res_ands = !indeterminate(!(true && tribool(true) && true && indeterminate)); // false
+  BOOST_TEST(!res_ands);
+  char array_ands[res_ands ? 2 : 3];
+  BOOST_TEST(sizeof(array_ands) / sizeof(char) == 3);
+
+  constexpr bool res_safe_bool = static_cast<bool>( tribool(true) );
+  BOOST_STATIC_ASSERT(res_safe_bool);
+
+// gcc 4.6 chokes on the xxx assignment
+# if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
+    constexpr tribool xxx = (tribool(true) || tribool(indeterminate));
+    BOOST_STATIC_ASSERT(xxx);
+# endif
+#endif
+
+  return boost::report_errors();
 }