diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a95d0c6251..024c707b31 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,3 +1,8 @@ +# Copyright 2026 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: @@ -8,117 +13,1213 @@ on: - develop - feature/** +concurrency: + group: ${{format('{0}:{1}', github.repository, github.ref)}} + cancel-in-progress: true + env: - UBSAN_OPTIONS: print_stacktrace=1 + 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.8 - cxxstd: 11 + cxxstd: "11" + extra_tests: 1 + os: ubuntu-latest container: ubuntu:18.04 + install: + - g++-4.8 + - toolset: gcc-4.9 + cxxstd: "11" os: ubuntu-latest - install: g++-4.8 + container: ubuntu:16.04 + install: + - g++-4.9 - toolset: gcc-5 - cxxstd: 11 - container: ubuntu:18.04 + cxxstd: "11,14,1z" + os: ubuntu-latest + container: ubuntu:16.04 + install: + - g++-5 + - toolset: gcc-6 + cxxstd: "11,14,1z" os: ubuntu-latest - install: g++-5 + container: ubuntu:18.04 + install: + - g++-6 - toolset: gcc-7 + cxxstd: "11,14,17" + os: ubuntu-latest container: ubuntu:18.04 + install: + - g++-7 + - toolset: gcc-8 + cxxstd: "14,17,2a" os: ubuntu-latest + container: ubuntu:18.04 + install: + - g++-8 - toolset: gcc-9 + cxxstd: "14,17,2a" + os: ubuntu-latest + container: ubuntu:20.04 + install: + - g++-9 + - toolset: gcc-10 + cxxstd: "14,17,20" + os: ubuntu-latest container: ubuntu:20.04 + install: + - g++-10 + - toolset: gcc-11 + cxxstd: "14-gnu,17-gnu" os: ubuntu-latest + container: ubuntu:22.04 + install: + - g++-11 - toolset: gcc-11 - os: ubuntu-22.04 + cxxstd: "20-gnu,23-gnu" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - g++-11 + - toolset: gcc-12 + cxxstd: "14-gnu,17-gnu" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - g++-12 + - toolset: gcc-12 + cxxstd: "20-gnu,23-gnu" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - g++-12 - toolset: gcc-13 + cxxstd: "14-gnu,17-gnu" + os: ubuntu-24.04 + install: + - g++-13 + - toolset: gcc-13 + cxxstd: "20-gnu,23-gnu" + os: ubuntu-24.04 + install: + - g++-13 + - toolset: gcc-14 + cxxstd: "14-gnu,17-gnu,20-gnu" os: ubuntu-24.04 + install: + - g++-14 + - toolset: gcc-14 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-24.04 + install: + - g++-14 + - toolset: gcc-15 + cxxstd: "14-gnu,17-gnu,20-gnu" + os: ubuntu-26.04 + install: + - g++-15 + - toolset: gcc-15 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-26.04 + install: + - g++-15 + - toolset: gcc-16 + cxxstd: "14-gnu,17-gnu,20-gnu" + os: ubuntu-26.04 + install: + - g++-16 + - toolset: gcc-16 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-26.04 + install: + - g++-16 + - name: UBSAN + toolset: gcc-15 + cxxstd: "14-gnu,17-gnu,20-gnu,23-gnu,26-gnu" + ubsan: 1 + build_variant: debug + os: ubuntu-26.04 + install: + - g++-15 + + # Linux, clang + - toolset: clang + compiler: clang++-3.7 + cxxstd: "11,14" + os: ubuntu-latest + container: ubuntu:16.04 + install: + - clang-3.7 + - toolset: clang + compiler: clang++-3.8 + cxxstd: "11,14" + os: ubuntu-latest + container: ubuntu:16.04 + install: + - clang-3.8 + - toolset: clang + compiler: clang++-3.9 + cxxstd: "11,14" + os: ubuntu-latest + container: ubuntu:18.04 + install: + - clang-3.9 + - toolset: clang + compiler: clang++-4.0 + cxxstd: "11,14" + os: ubuntu-latest + container: ubuntu:18.04 + install: + - clang-4.0 + - toolset: clang + compiler: clang++-5.0 + cxxstd: "14,1z" + os: ubuntu-latest + container: ubuntu:18.04 + install: + - clang-5.0 + - toolset: clang + compiler: clang++-6.0 + cxxstd: "14,17" + os: ubuntu-latest + container: ubuntu:18.04 + install: + - clang-6.0 + - toolset: clang + compiler: clang++-7 + cxxstd: "14,17" + os: ubuntu-latest + container: 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: "14,17,2a" + os: ubuntu-latest + container: ubuntu:18.04 + install: + - clang-8 + - g++-7 + gcc_toolchain: 7 + - toolset: clang + compiler: clang++-9 + cxxstd: "14,17,2a" + os: ubuntu-latest container: ubuntu:20.04 + install: + - clang-9 + - toolset: clang + compiler: clang++-10 + cxxstd: "14,17,20" + os: ubuntu-latest + container: ubuntu:20.04 + install: + - clang-10 + - toolset: clang + compiler: clang++-11 + cxxstd: "14,17,20" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - clang-11 + - g++-11 + gcc_toolchain: 11 + - toolset: clang + compiler: clang++-12 + cxxstd: "17-gnu,20-gnu,2b-gnu" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - clang-12 + - g++-11 + gcc_toolchain: 11 + - toolset: clang + compiler: clang++-13 + cxxstd: "17-gnu,20-gnu,2b-gnu" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - clang-13 + - g++-11 + gcc_toolchain: 11 + - toolset: clang + compiler: clang++-14 + cxxstd: "17-gnu,20-gnu,2b-gnu" os: ubuntu-latest - install: clang + container: ubuntu:22.04 + install: + - clang-14 + - g++-11 + gcc_toolchain: 11 - toolset: clang - os: ubuntu-22.04 + compiler: clang++-15 + cxxstd: "17-gnu,20-gnu,2b-gnu" + os: ubuntu-latest + container: ubuntu:22.04 + install: + - clang-15 + - g++-11 + gcc_toolchain: 11 + - toolset: clang + compiler: clang++-16 + cxxstd: "17-gnu,20-gnu,2b-gnu" + os: ubuntu-24.04 + install: + - clang-16 + - g++-11 + gcc_toolchain: 11 - toolset: clang - cxxstd: 20 + compiler: clang++-17 + cxxstd: "17-gnu,20-gnu,23-gnu" os: ubuntu-24.04 + install: + - clang-17 + - g++-11 + gcc_toolchain: 11 - toolset: clang - os: macos-13 - cxxstd: 11 + compiler: clang++-18 + cxxstd: "17-gnu,20-gnu" + os: ubuntu-24.04 + install: + - clang-18 + - g++-13 + - toolset: clang + compiler: clang++-18 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-24.04 + install: + - clang-18 + - g++-13 + - toolset: clang + compiler: clang++-19 + cxxstd: "17-gnu,20-gnu" + os: ubuntu-24.04 + install: + - clang-19 + - toolset: clang + compiler: clang++-19 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-24.04 + install: + - clang-19 + - toolset: clang + compiler: clang++-20 + cxxstd: "17-gnu,20-gnu" + os: ubuntu-26.04 + install: + - clang-20 + - toolset: clang + compiler: clang++-20 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-26.04 + install: + - clang-20 + - toolset: clang + compiler: clang++-21 + cxxstd: "17-gnu,20-gnu" + os: ubuntu-26.04 + install: + - clang-21 + - toolset: clang + compiler: clang++-21 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-26.04 + install: + - clang-21 + - toolset: clang + compiler: clang++-22 + cxxstd: "17-gnu,20-gnu" + os: ubuntu-26.04 + install: + - clang-22 + - toolset: clang + compiler: clang++-22 + cxxstd: "23-gnu,26-gnu" + os: ubuntu-26.04 + install: + - clang-22 + - toolset: clang + compiler: clang++-22 + cxxstd: "11-gnu,14-gnu" + cxxflags: -stdlib=libc++ + linkflags: -stdlib=libc++ + extra_tests: 1 + os: ubuntu-26.04 + install: + - clang-22 + - libc++-22-dev + - libc++abi-22-dev + - toolset: clang + compiler: clang++-22 + cxxstd: "17-gnu,20-gnu" + cxxflags: -stdlib=libc++ + linkflags: -stdlib=libc++ + os: ubuntu-26.04 + install: + - clang-22 + - libc++-22-dev + - libc++abi-22-dev + - toolset: clang + compiler: clang++-22 + cxxstd: "23-gnu,26-gnu" + cxxflags: -stdlib=libc++ + linkflags: -stdlib=libc++ + os: ubuntu-26.04 + install: + - clang-22 + - libc++-22-dev + - libc++abi-22-dev + - name: UBSAN + toolset: clang + compiler: clang++-22 + cxxstd: "17-gnu,20-gnu,23-gnu,26-gnu" + cxxflags: -stdlib=libc++ + linkflags: "-stdlib=libc++ -lubsan" + ubsan: 1 + build_variant: debug + os: ubuntu-26.04 + install: + - clang-22 + - libc++-22-dev + - libc++abi-22-dev + + - toolset: clang + vm: freebsd + version: "14.3" + cxxstd: "11,14" + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + - toolset: clang + vm: freebsd + version: "14.3" + cxxstd: "17,20,23,26" + build_variant: debug + os: ubuntu-latest + + - toolset: clang + vm: openbsd + version: "7.7" + cxxstd: "11,14" + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + - toolset: clang + vm: openbsd + version: "7.7" + cxxstd: "17,20,2b" + build_variant: debug + os: ubuntu-latest + + - toolset: gcc + vm: netbsd + version: "10.1" + cxxstd: "11" + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + - toolset: gcc + vm: netbsd + version: "10.1" + cxxstd: "14,17,20" + build_variant: debug + os: ubuntu-latest + + - toolset: gcc + vm: dragonflybsd + version: "6.4.0" + cxxstd: "11" + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + lang: en_US.UTF-8 + - toolset: gcc + vm: dragonflybsd + version: "6.4.0" + cxxstd: "14,17,2a" + build_variant: debug + os: ubuntu-latest + lang: en_US.UTF-8 + + - toolset: gcc + vm: solaris + version: "11.4-gcc" + cxxstd: "11,14" + cxxflags: -D__SunOS_5_11 + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + - toolset: gcc + vm: solaris + version: "11.4-gcc" + cxxstd: "17,20,23,26" + cxxflags: -D__SunOS_5_11 + build_variant: debug + os: ubuntu-latest + + - toolset: gcc + vm: omnios + version: "r151056-build" + cxxstd: "11,14" + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + - toolset: gcc + vm: omnios + version: "r151056-build" + cxxstd: "17,20" + build_variant: debug + os: ubuntu-latest + - toolset: gcc + vm: omnios + version: "r151056-build" + cxxstd: "23,26" + build_variant: debug + os: ubuntu-latest + + - toolset: gcc + vm: openindiana + version: "202510-build" + cxxstd: "11,14" + extra_tests: 1 + build_variant: debug + os: ubuntu-latest + - toolset: gcc + vm: openindiana + version: "202510-build" + cxxstd: "17,20" + build_variant: debug + os: ubuntu-latest + - toolset: gcc + vm: openindiana + version: "202510-build" + cxxstd: "23,26" + build_variant: debug + os: ubuntu-latest + + - toolset: clang + os: macos-14 + cxxstd: "11" + extra_tests: 1 + build_variant: debug - toolset: clang os: macos-14 - cxxstd: 14 + cxxstd: "14,17,20,2b" + build_variant: debug - toolset: clang os: macos-15 - cxxstd: 17 + cxxstd: "14,17,20,23,26" + build_variant: debug + - toolset: clang + os: macos-26 + cxxstd: "14,17,20,23,26" + build_variant: debug + timeout-minutes: 150 runs-on: ${{matrix.os}} + container: ${{matrix.container}} - container: - image: ${{matrix.container}} - volumes: - - /node20217:/node20217:rw,rshared - - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }} + steps: + - name: Setup environment + run: | + if [ -n "${{matrix.lang}}" ] + then + echo "LANG=${{matrix.lang}}" >> $GITHUB_ENV + export LANG=${{matrix.lang}} + fi + 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 + # Use Azure APT mirrors in containers to avoid HTTP errors due to DDoS filters triggered by lots of CI jobs launching concurrently. + # Note that not all Ubuntu versions support "mirror+file:..." URIs in APT sources, so just use Azure mirrors exclusively. + # Note also that on recent Ubuntu versions DEB822 format is used for source files. + APT_SOURCES=() + if [ -d "/etc/apt/sources.list.d" ] + then + readarray -t APT_SOURCES < <(find "/etc/apt/sources.list.d" -type f -name '*.sources' -print) + fi + if [ -f "/etc/apt/sources.list" ] + then + APT_SOURCES+=("/etc/apt/sources.list") + fi + if [ "${#APT_SOURCES[@]}" -gt 0 ] + then + sed -i -E -e 's!([^ ]+) (http|https)://(archive|security)\.ubuntu\.com/ubuntu[^ ]*(.*)!\1 http://azure.archive.ubuntu.com/ubuntu/\4!' "${APT_SOURCES[@]}" + fi + apt-get -o Acquire::Retries=$NET_RETRY_COUNT update + if [ "$(apt-cache search "^python-is-python3$" | wc -l)" -ne 0 ] + then + PYTHON_PACKAGE="python-is-python3" + else + PYTHON_PACKAGE="python" + fi + 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_PACKAGE python3 perl git cmake + fi + fi + git config --global pack.threads 0 + + - name: Install packages + if: matrix.install + run: | + declare -a SOURCE_KEYS SOURCES + if [ -n "${{join(matrix.source_keys, ' ')}}" ] + then + SOURCE_KEYS=("${{join(matrix.source_keys, '" "')}}") + fi + if [ -n "${{join(matrix.sources, ' ')}}" ] + then + SOURCES=("${{join(matrix.sources, '" "')}}") + fi + for key in "${SOURCE_KEYS[@]}" + do + for i in {1..$NET_RETRY_COUNT} + do + echo "Adding key: $key" + 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_SUPPORTED_ARGS="$(apt-add-repository --help | perl -ne 'if (/^\s*-n/) { print "n"; } elsif (/^\s*-P/) { print "P"; } elsif (/^\s*-S/) { print "S"; } elsif (/^\s*-U/) { print "U"; }')" + if [ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*n*}" ] + then + APT_ADD_REPO_COMMON_ARGS+=("-n") + fi + APT_ADD_REPO_HAS_SOURCE_ARGS="$([ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*P*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*S*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*U*}" ] && echo 1 || echo 0)" + 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") + echo "apt-add-repository ${APT_ADD_REPO_ARGS[@]}" + 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 + echo BUILD_JOBS: $BUILD_JOBS + declare -a DEPINST_ARGS=() + 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 + DEPINST_ARGS+=("--git_args" "--jobs $GIT_FETCH_JOBS") + fi + mkdir -p snapshot + cd snapshot + echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz" + curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz" + tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz" + if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ] + then + echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:" + ls -la + exit 1 + fi + rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz" + cd .. + git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root" + cd boost-root + mkdir -p libs + rm -rf "libs/$LIBRARY" + mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY" + rm -rf "../snapshot" + git submodule update --init tools/boostdep + DEPINST_ARGS+=("$LIBRARY") + python tools/boostdep/depinst/depinst.py "${DEPINST_ARGS[@]}" + rm -rf ".git" + cd .. + cat > b2-run-tests.sh << "EOF" + #!/usr/bin/env bash + set -e + cd boost-root + ./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 " : \"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" \"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam + fi + echo " ;" >> ~/user-config.jam + fi + if [ -z "${{matrix.extra_tests}}" ] + then + export BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1 + fi + declare -a 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" "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[@]}" + EOF + chmod +x b2-run-tests.sh + + # Note: The VMs must be created after the workspace is fully prepared, as it will be copied to the VM only once + - name: Setup FreeBSD VM + if: matrix.vm == 'freebsd' + uses: vmactions/freebsd-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + prepare: | + pkg install -y bash + run: | + uname -mrs + sysctl hw.model + sysctl hw.ncpu + sysctl hw.physmem + sysctl hw.usermem + locale + pwd + ls -la + - name: Setup OpenBSD VM + if: matrix.vm == 'openbsd' + uses: vmactions/openbsd-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + prepare: | + pkg_add bash + run: | + uname -mrs + sysctl hw.model + sysctl hw.ncpu + sysctl hw.physmem + sysctl hw.usermem + locale + pwd + ls -la + + - name: Setup NetBSD VM + if: matrix.vm == 'netbsd' + uses: vmactions/netbsd-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + run: | + uname -mrs + /sbin/sysctl hw.model + /sbin/sysctl hw.ncpu + /sbin/sysctl hw.physmem64 + /sbin/sysctl hw.usermem64 + locale + pwd + ls -la + + - name: Setup DragonFlyBSD VM + if: matrix.vm == 'dragonflybsd' + uses: vmactions/dragonflybsd-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + prepare: | + pkg install -y bash + run: | + uname -mrs + sysctl hw.model + sysctl hw.ncpu + sysctl hw.physmem + sysctl hw.usermem + locale + pwd + ls -la + + - name: Setup Solaris VM + if: matrix.vm == 'solaris' + uses: vmactions/solaris-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + run: | + uname -mrs + locale + pwd + ls -la + + - name: Setup OmniOS VM + if: matrix.vm == 'omnios' + uses: vmactions/omnios-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + run: | + uname -mrs + locale + pwd + ls -la + + - name: Setup OpenIndiana VM + if: matrix.vm == 'openindiana' + uses: vmactions/openindiana-vm@v1 + with: + release: "${{matrix.version}}" + custom-shell-name: vmsh + usesh: true + sync: rsync + copyback: false + envs: "LANG LIBRARY DEFAULT_BUILD_VARIANT BUILD_JOBS GCC_TOOLCHAIN_ROOT" + run: | + uname -mrs + locale + pwd + ls -la + + - name: Run tests + if: matrix.cmake_tests == '' && matrix.vm == '' + run: | + bash ./b2-run-tests.sh + + - name: Run tests (VM) + if: matrix.cmake_tests == '' && matrix.vm != '' + shell: vmsh {0} + run: | + cd "$GITHUB_WORKSPACE" + bash ./b2-run-tests.sh + + windows: defaults: run: - shell: bash + shell: cmd + + strategy: + fail-fast: false + matrix: + include: + - toolset: msvc-14.3 + cxxstd: "14" + addrmd: 64 + extra_tests: 1 + os: windows-2022 + - toolset: msvc-14.3 + cxxstd: "17,20,latest" + addrmd: 64 + os: windows-2022 + - toolset: msvc-14.3 + cxxstd: "14,17" + addrmd: 32 + os: windows-2022 + - toolset: msvc-14.3 + cxxstd: "20,latest" + addrmd: 32 + os: windows-2022 + - toolset: clang-win + cxxstd: "14,17,latest" + addrmd: 64 + os: windows-2022 + - toolset: clang-win + cxxstd: "14,17,latest" + addrmd: 32 + os: windows-2022 + - toolset: gcc + cxxstd: "17,20,23" + addrmd: 64 + build_variant: debug + os: windows-2022 + + timeout-minutes: 150 + runs-on: ${{matrix.os}} steps: - - name: Setup container environment - if: matrix.container + - name: Setup Boost run: | - apt-get update - apt-get -y install sudo python3 git g++ curl xz-utils + 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% + mkdir snapshot + cd snapshot + echo Downloading library snapshot: https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip + curl -L --retry %NET_RETRY_COUNT% -o "%LIBRARY%-%GITHUB_SHA%.zip" "https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip" + tar -xf "%LIBRARY%-%GITHUB_SHA%.zip" + if not exist "%LIBRARY%-%GITHUB_SHA%\" ( + echo Library snapshot does not contain the library directory %LIBRARY%-%GITHUB_SHA%: + dir + exit /b 1 + ) + del /f "%LIBRARY%-%GITHUB_SHA%.zip" + cd .. + git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root + cd boost-root + if not exist "libs\" mkdir libs + if exist "libs\%LIBRARY%\" rmdir /s /q "libs\%LIBRARY%" + move /Y "..\snapshot\%LIBRARY%-%GITHUB_SHA%" "libs\%LIBRARY%" + rmdir /s /q "..\snapshot" + git submodule update --init tools/boostdep + python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" %LIBRARY% + if "${{matrix.cmake_tests}}" == "" ( + cmd /c bootstrap + b2 -d0 headers + ) - - name: Install nodejs20glibc2.17 - if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }} + - name: Run tests + if: matrix.cmake_tests == '' run: | - curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz - tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217 - ldd /__e/node20/bin/node + cd boost-root + if not "${{matrix.cxxstd}}" == "" set CXXSTD=cxxstd=${{matrix.cxxstd}} + if not "${{matrix.addrmd}}" == "" set ADDRMD=address-model=${{matrix.addrmd}} + if not "${{matrix.build_variant}}" == "" (set BUILD_VARIANT=variant=${{matrix.build_variant}}) else (set BUILD_VARIANT=variant=%DEFAULT_BUILD_VARIANT%) + if "${{matrix.extra_tests}}" == "" set BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1 + b2 -j %NUMBER_OF_PROCESSORS% libs/%LIBRARY%/test toolset=${{matrix.toolset}} %CXXSTD% %ADDRMD% %BUILD_VARIANT% embed-manifest-via=linker - - uses: actions/checkout@v4 + MSYS2: + defaults: + run: + shell: msys2 {0} + strategy: + fail-fast: false + matrix: + include: + - sys: MINGW32 + toolset: gcc + cxxstd: '17,20,23' + build_variant: debug + - sys: MINGW64 + toolset: gcc + cxxstd: '17,20,23' + build_variant: debug - - name: Install packages - if: matrix.install - run: | - sudo apt-get update - sudo apt-get -y install ${{matrix.install}} + timeout-minutes: 150 + runs-on: windows-latest + + steps: + - name: Setup MSYS2 environment + uses: msys2/setup-msys2@v2 + with: + msystem: ${{matrix.sys}} + update: true + install: git python + pacboy: gcc:p - 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 - cd .. - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root - cd boost-root - cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY - git submodule update --init tools/boostdep - python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY - ./bootstrap.sh - ./b2 -d0 headers - - - name: Create user-config.jam - if: matrix.compiler + 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 + mkdir -p snapshot + cd snapshot + echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz" + curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz" + tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz" + if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ] + then + echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:" + ls -la + exit 1 + fi + rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz" + cd .. + git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root" + cd boost-root + mkdir -p libs + rm -rf "libs/$LIBRARY" + mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY" + rm -rf "../snapshot" + git submodule update --init tools/boostdep + python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" "$LIBRARY" + ./bootstrap.sh + ./b2 headers + + - name: Run tests + run: | + cd boost-root + if [ -z "${{matrix.extra_tests}}" ] + then + export BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1 + fi + declare -a 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" "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[@]}" + + cygwin: + defaults: + run: + shell: bash + + env: + SHELLOPTS: igncr + CYGWIN: winsymlinks:native + + strategy: + fail-fast: false + matrix: + include: + - toolset: gcc + cxxstd: "11-gnu" + extra_tests: 1 + build_variant: debug + - toolset: gcc + cxxstd: "14-gnu,17-gnu" + build_variant: debug + - toolset: gcc + cxxstd: "20-gnu" + build_variant: debug + - toolset: gcc + cxxstd: "23-gnu" + build_variant: debug + + timeout-minutes: 150 + runs-on: windows-latest + + steps: + - name: Configure git + run: | + git config --global core.autocrlf input + + - name: Install Cygwin + uses: cygwin/cygwin-install-action@v6 + with: + packages: + gcc-g++ + + - name: Setup Boost run: | - echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam + 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) 2> /dev/null) + echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV + echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV + declare -a DEPINST_ARGS=("--git_args" "--jobs $GIT_FETCH_JOBS") + mkdir -p snapshot + cd snapshot + echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz" + curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz" + tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz" + if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ] + then + echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:" + ls -la + exit 1 + fi + rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz" + cd .. + git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root" + cd boost-root + mkdir -p libs + rm -rf "libs/$LIBRARY" + mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY" + rm -rf "../snapshot" + git submodule update --init tools/boostdep + DEPINST_ARGS+=("$LIBRARY") + python tools/boostdep/depinst/depinst.py "${DEPINST_ARGS[@]}" + ./bootstrap.sh + ./b2 -d0 headers - name: Run tests run: | - cd ../boost-root - export CXXSTD=${{matrix.cxxstd}} - ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} ${CXXSTD:+cxxstd=$CXXSTD} variant=debug,release + cd boost-root + if [ -z "${{matrix.extra_tests}}" ] + then + export BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1 + fi + declare -a 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" "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[@]}" diff --git a/CMakeLists.txt b/CMakeLists.txt index d0507d4677..d13a693aa6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -69,7 +69,6 @@ target_link_libraries(boost_thread Boost::predef Boost::preprocessor Boost::smart_ptr - Boost::static_assert Boost::system Boost::throw_exception Boost::tuple diff --git a/build.jam b/build.jam new file mode 100644 index 0000000000..7cb3cb926a --- /dev/null +++ b/build.jam @@ -0,0 +1,45 @@ +# Copyright René Ferdinand Rivera Morell 2023-2024 +# 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) + +require-b2 5.2 ; + +constant boost_dependencies : + /boost/assert//boost_assert + /boost/atomic//boost_atomic + /boost/bind//boost_bind + /boost/chrono//boost_chrono + /boost/concept_check//boost_concept_check + /boost/config//boost_config + /boost/container//boost_container + /boost/container_hash//boost_container_hash + /boost/core//boost_core + /boost/date_time//boost_date_time + /boost/exception//boost_exception + /boost/function//boost_function + /boost/io//boost_io + /boost/move//boost_move + /boost/optional//boost_optional + /boost/predef//boost_predef + /boost/preprocessor//boost_preprocessor + /boost/smart_ptr//boost_smart_ptr + /boost/system//boost_system + /boost/throw_exception//boost_throw_exception + /boost/tuple//boost_tuple + /boost/type_traits//boost_type_traits + /boost/utility//boost_utility + /boost/winapi//boost_winapi ; + +project /boost/thread + ; + +explicit + [ alias boost_thread : build//boost_thread ] + [ alias all : boost_thread example test ] + ; + +call-if : boost-library thread + : install boost_thread + ; + diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index 1a88d01020..5be59046a3 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -35,18 +35,22 @@ import os ; import indirect ; import path ; -import configure ; +import configure ; import threadapi-feature ; exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ; -project boost/thread +project : source-location ../src + : common-requirements + $(boost_dependencies) + ../include : requirements multi #static:BOOST_THREAD_STATIC_LINK=1 #shared:BOOST_THREAD_DYN_LINK=1 static:BOOST_THREAD_BUILD_LIB=1 shared:BOOST_THREAD_BUILD_DLL=1 + -@%boostcpp.tag -@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag @$(__name__).tag gcc:-Wno-long-long @@ -139,6 +143,7 @@ project boost/thread #BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED #BOOST_SYSTEM_NO_DEPRECATED #BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS + BOOST_THREAD_NO_LIB=1 ; rule tag ( name : type ? : property-set ) @@ -156,8 +161,15 @@ rule tag ( name : type ? : property-set ) } # forward to the boost tagging rule - return [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag - $(result) : $(type) : $(property-set) ] ; + if $(BOOST_JAMROOT_MODULE) + { + return [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag + $(result) : $(type) : $(property-set) ] ; + } + else + { + return $(result) ; + } } rule win32_pthread_paths ( properties * ) @@ -269,10 +281,10 @@ rule requirements ( properties * ) } } result += BOOST_THREAD_DONT_USE_CHRONO ; - if ! [ configure.builds has_atomic_flag_lockfree - : $(properties) : "lockfree boost::atomic_flag" ] { - result += /boost/atomic//boost_atomic ; - } + if ! [ configure.builds has_atomic_flag_lockfree + : $(properties) : "lockfree boost::atomic_flag" ] { + result += /boost/atomic//boost_atomic ; + } } else { if win32 in $(properties) { @@ -315,5 +327,3 @@ lib boost_thread static:BOOST_THREAD_USE_LIB=1 @usage-requirements ; - -boost-install boost_thread ; \ No newline at end of file diff --git a/doc/emulations.qbk b/doc/emulations.qbk index 61774af825..031b8c0200 100644 --- a/doc/emulations.qbk +++ b/doc/emulations.qbk @@ -1,5 +1,5 @@ [/ - (C) Copyright 20012 Vicente J. Botet Escriba. + (C) Copyright 2012 Vicente J. Botet Escriba. 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). diff --git a/doc/overview.qbk b/doc/overview.qbk index 26bb187f87..cbc040010b 100644 --- a/doc/overview.qbk +++ b/doc/overview.qbk @@ -1,6 +1,6 @@ [/ (C) Copyright 2007-12 Anthony Williams. - (C) Copyright 20012 Vicente J. Botet Escriba. + (C) Copyright 2012 Vicente J. Botet Escriba. 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). diff --git a/doc/scoped_thread.qbk b/doc/scoped_thread.qbk index 13437be529..5c5f2440fd 100644 --- a/doc/scoped_thread.qbk +++ b/doc/scoped_thread.qbk @@ -1,6 +1,6 @@ [/ (C) Copyright 2008-9 Anthony Williams. - (C) Copyright 12 Vicente J. Botet Escriba. + (C) Copyright 2012 Vicente J. Botet Escriba. 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). diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index bfc8a59b3c..fbdf760c50 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -4,7 +4,7 @@ # 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) -project boost/thread/example +project : requirements ../build//boost_thread multi ; diff --git a/example/make_future.cpp b/example/make_future.cpp index 76207d7ad8..2fd53f9628 100644 --- a/example/make_future.cpp +++ b/example/make_future.cpp @@ -112,21 +112,21 @@ int main() #if __cplusplus > 201103L { std::cout << __FILE__ << " "<< __LINE__ << std::endl; - int i = 0; - boost::future f = boost::make_ready_future(std::ref(i)); + int x = 0; + boost::future f = boost::make_ready_future(std::ref(x)); std::cout << f.get() << std::endl; } #endif { std::cout << __FILE__ << " "<< __LINE__ << std::endl; - int i = 0; - boost::future f = boost::make_ready_future(boost::ref(i)); + int x = 0; + boost::future f = boost::make_ready_future(boost::ref(x)); std::cout << f.get() << std::endl; } { std::cout << __FILE__ << " "<< __LINE__ << std::endl; - const int i = 0; - boost::future f = boost::make_ready_future(boost::cref(i)); + const int x = 0; + boost::future f = boost::make_ready_future(boost::cref(x)); std::cout << f.get() << std::endl; } { @@ -142,12 +142,12 @@ int main() } catch (std::exception& ex) { - std::cout << "ERRORRRRR "< #include -boost::mutex io_mutex; // The iostreams are not guaranteed to be thread-safe! +boost::mutex g_io_mutex; // The iostreams are not guaranteed to be thread-safe! class counter { @@ -25,12 +25,12 @@ class counter int count; }; -counter c; +counter g_counter; void change_count() { - int i = c.increment(); - boost::unique_lock scoped_lock(io_mutex); + int i = g_counter.increment(); + boost::unique_lock scoped_lock(g_io_mutex); std::cout << "count == " << i << std::endl; } diff --git a/example/once.cpp b/example/once.cpp index c063a9ce45..d248ad8502 100644 --- a/example/once.cpp +++ b/example/once.cpp @@ -10,23 +10,23 @@ #include #include -int value=0; +int g_value=0; #ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11 -static boost::once_flag once; -//static boost::once_flag once2 = BOOST_ONCE_INIT; +static boost::once_flag g_once; +//static boost::once_flag g_once2 = BOOST_ONCE_INIT; #else -static boost::once_flag once = BOOST_ONCE_INIT; -//static boost::once_flag once2 = once; +static boost::once_flag g_once = BOOST_ONCE_INIT; +//static boost::once_flag g_once2 = g_once; #endif void init() { - ++value; + ++g_value; } void thread_proc() { - boost::call_once(&init, once); + boost::call_once(&init, g_once); } int main() @@ -35,5 +35,5 @@ int main() for (int i=0; i<5; ++i) threads.create_thread(&thread_proc); threads.join_all(); - assert(value == 1); + assert(g_value == 1); } diff --git a/example/producer_consumer.cpp b/example/producer_consumer.cpp index 73ad04fb72..4917ea0efa 100644 --- a/example/producer_consumer.cpp +++ b/example/producer_consumer.cpp @@ -54,6 +54,7 @@ void consumer( try { for(int i=0; ;++i) { + (void)i; int r; sbq.pull(r); //sbq >> r; @@ -77,6 +78,7 @@ void consumer2(the_ostream &/*mos*/, boost::sync_queue & sbq) try { for(int i=0; ;++i) { + (void)i; int r; queue_op_status st = sbq.try_pull(r); if (queue_op_status::closed == st) break; @@ -97,6 +99,7 @@ void consumer3(the_ostream &/*mos*/, boost::sync_queue & sbq) try { for(int i=0; ;++i) { + (void)i; int r; queue_op_status res = sbq.wait_pull(r); if (res==queue_op_status::closed) break; diff --git a/example/producer_consumer2.cpp b/example/producer_consumer2.cpp index a8264a9bbc..b765b4d924 100644 --- a/example/producer_consumer2.cpp +++ b/example/producer_consumer2.cpp @@ -57,6 +57,7 @@ void consumer( try { for(int i=0; ;++i) { + (void)i; int r; sbq.pull(r); //sbq >> r; @@ -80,6 +81,7 @@ void consumer2(the_ostream &/*mos*/, boost::queue_front sbq) try { for(int i=0; ;++i) { + (void)i; int r; queue_op_status st = sbq.try_pull(r); if (queue_op_status::closed == st) break; @@ -100,6 +102,7 @@ void consumer3(the_ostream &/*mos*/, boost::queue_front sbq) try { for(int i=0; ;++i) { + (void)i; int r; queue_op_status res = sbq.wait_pull(r); if (res==queue_op_status::closed) break; diff --git a/example/producer_consumer_bounded.cpp b/example/producer_consumer_bounded.cpp index 70158a3e94..0d8d04f380 100644 --- a/example/producer_consumer_bounded.cpp +++ b/example/producer_consumer_bounded.cpp @@ -55,6 +55,7 @@ void consumer(the_ostream &/*mos*/, boost::sync_bounded_queue & sbq) try { for(int i=0; ;++i) { + (void)i; int r; sbq.pull_front(r); //sbq >> r; @@ -77,6 +78,7 @@ void consumer2(the_ostream &/*mos*/, boost::sync_bounded_queue & sbq) try { for(int i=0; ;++i) { + (void)i; int r; queue_op_status st = sbq.try_pull_front(r); if (queue_op_status::closed == st) break; diff --git a/example/recursive_mutex.cpp b/example/recursive_mutex.cpp index 8cb99d30d3..5ef259b0e6 100644 --- a/example/recursive_mutex.cpp +++ b/example/recursive_mutex.cpp @@ -28,11 +28,11 @@ class counter int count; }; -counter c; +counter g_counter; void change_count() { - //std::cout << "count == " << c.increment() << std::endl; + //std::cout << "count == " << g_counter.increment() << std::endl; } int main(int, char*[]) diff --git a/example/std_thread_guard.cpp b/example/std_thread_guard.cpp index ebf5a41738..feb746591e 100644 --- a/example/std_thread_guard.cpp +++ b/example/std_thread_guard.cpp @@ -26,6 +26,7 @@ struct func int& i; func(int& i_):i(i_){} + func(func const& that):i(that.i){} void operator()() { diff --git a/example/tennis.cpp b/example/tennis.cpp index d560ecb920..6a1a83ec22 100644 --- a/example/tennis.cpp +++ b/example/tennis.cpp @@ -28,9 +28,9 @@ enum game_state BOTH_PLAYERS_GONE }; -int state; -boost::mutex mutex; -boost::condition cond; +int g_state; +boost::mutex g_mutex; +boost::condition g_cond; const char* player_name(int state) { @@ -44,29 +44,29 @@ const char* player_name(int state) void player(int active) { - boost::unique_lock lock(mutex); + boost::unique_lock lock(g_mutex); int other = active == PLAYER_A ? PLAYER_B : PLAYER_A; - while (state < GAME_OVER) + while (g_state < GAME_OVER) { //std::cout << player_name(active) << ": Play." << std::endl; - state = other; - cond.notify_all(); + g_state = other; + g_cond.notify_all(); do { - cond.wait(lock); - if (state == other) + g_cond.wait(lock); + if (g_state == other) { std::cout << "---" << player_name(active) << ": Spurious wakeup!" << std::endl; } - } while (state == other); + } while (g_state == other); } - ++state; + ++g_state; std::cout << player_name(active) << ": Gone." << std::endl; - cond.notify_all(); + g_cond.notify_all(); } struct thread_adapt @@ -100,7 +100,7 @@ class thread_adapter int main() { - state = START; + g_state = START; boost::thread thrda(&player, PLAYER_A); boost::thread thrdb(&player, PLAYER_B); @@ -110,22 +110,22 @@ int main() xt.sec += 1; boost::thread::sleep(xt); { - boost::unique_lock lock(mutex); + boost::unique_lock lock(g_mutex); std::cout << "---Noise ON..." << std::endl; } for (int i = 0; i < 10; ++i) - cond.notify_all(); + g_cond.notify_all(); { - boost::unique_lock lock(mutex); + boost::unique_lock lock(g_mutex); std::cout << "---Noise OFF..." << std::endl; - state = GAME_OVER; - cond.notify_all(); + g_state = GAME_OVER; + g_cond.notify_all(); do { - cond.wait(lock); - } while (state != BOTH_PLAYERS_GONE); + g_cond.wait(lock); + } while (g_state != BOTH_PLAYERS_GONE); } std::cout << "GAME OVER" << std::endl; diff --git a/example/thread_group.cpp b/example/thread_group.cpp index 1256a1045b..56a693a123 100644 --- a/example/thread_group.cpp +++ b/example/thread_group.cpp @@ -8,23 +8,22 @@ #include #include -int count = 0; -boost::mutex mutex; +int g_count = 0; +boost::mutex g_mutex; void increment_count() { - boost::unique_lock lock(mutex); - std::cout << "count = " << ++count << std::endl; + boost::unique_lock lock(g_mutex); + std::cout << "count = " << ++g_count << std::endl; } -boost::thread_group threads2; -boost::thread* th2 = 0; +boost::thread_group g_threads2; void increment_count_2() { - boost::unique_lock lock(mutex); - BOOST_TEST(threads2.is_this_thread_in()); - std::cout << "count = " << ++count << std::endl; + boost::unique_lock lock(g_mutex); + BOOST_TEST(g_threads2.is_this_thread_in()); + std::cout << "count = " << ++g_count << std::endl; } int main() @@ -63,11 +62,11 @@ int main() } { { - boost::unique_lock lock(mutex); + boost::unique_lock lock(g_mutex); boost::thread* th2 = new boost::thread(&increment_count_2); - threads2.add_thread(th2); + g_threads2.add_thread(th2); } - threads2.join_all(); + g_threads2.join_all(); } return boost::report_errors(); } diff --git a/example/tss.cpp b/example/tss.cpp index f5f108e114..fdab19a519 100644 --- a/example/tss.cpp +++ b/example/tss.cpp @@ -8,21 +8,21 @@ #include #include -boost::thread_specific_ptr value; +boost::thread_specific_ptr g_value; void increment() { - int* p = value.get(); + int* p = g_value.get(); ++*p; } void thread_proc() { - value.reset(new int(0)); // initialize the thread's storage + g_value.reset(new int(0)); // initialize the thread's storage for (int i=0; i<10; ++i) { increment(); - int* p = value.get(); + int* p = g_value.get(); assert(*p == i+1); (void)(p); } diff --git a/example/with_lock_guard.cpp b/example/with_lock_guard.cpp index f3a4cd8064..a98f5d3475 100644 --- a/example/with_lock_guard.cpp +++ b/example/with_lock_guard.cpp @@ -12,18 +12,18 @@ #include #include -boost::mutex m; // protection for 'x' and 'std::cout' -int x; +boost::mutex g_mutex; // protection for 'g_x' and 'std::cout' +int g_x = 0; #if defined(BOOST_NO_CXX11_LAMBDAS) || (defined BOOST_MSVC && _MSC_VER < 1700) void print_x() { - ++x; - std::cout << "x = " << x << std::endl; + ++g_x; + std::cout << "x = " << g_x << std::endl; } void job() { for (int i = 0; i < 10; ++i) { - boost::with_lock_guard(m, print_x); + boost::with_lock_guard(g_mutex, print_x); boost::this_thread::sleep_for(boost::chrono::milliseconds(100)); } } @@ -31,10 +31,10 @@ void job() { void job() { for (int i = 0; i < 10; ++i) { boost::with_lock_guard( - m, + g_mutex, []() { - ++x; - std::cout << "x = " << x << std::endl; + ++g_x; + std::cout << "x = " << g_x << std::endl; } ); boost::this_thread::sleep_for(boost::chrono::milliseconds(100)); diff --git a/include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp b/include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp index 0897681928..bcabaa38a0 100644 --- a/include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp +++ b/include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp @@ -12,6 +12,7 @@ ////////////////////////////////////////////////////////////////////////////// #include +#include #include #include @@ -187,7 +188,7 @@ namespace detail template bool sync_deque_base::wait_until_not_empty_or_closed(unique_lock& lk) { - cond_.wait(lk, boost::bind(&sync_deque_base::not_empty_or_closed, boost::ref(*this), boost::ref(lk))); + cond_.wait(lk, boost::bind(&sync_deque_base::not_empty_or_closed, this, boost::ref(lk))); if (! empty(lk)) return false; // success return true; // closed } @@ -196,7 +197,7 @@ namespace detail template queue_op_status sync_deque_base::wait_until_not_empty_or_closed_until(unique_lock& lk, chrono::time_point const&tp) { - if (! cond_.wait_until(lk, tp, boost::bind(&sync_deque_base::not_empty_or_closed, boost::ref(*this), boost::ref(lk)))) + if (! cond_.wait_until(lk, tp, boost::bind(&sync_deque_base::not_empty_or_closed, this, boost::ref(lk)))) return queue_op_status::timeout; if (! empty(lk)) return queue_op_status::success; return queue_op_status::closed; diff --git a/include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp b/include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp index 2b3d27b728..71379e7129 100644 --- a/include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp +++ b/include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp @@ -12,6 +12,7 @@ ////////////////////////////////////////////////////////////////////////////// #include +#include #include #include @@ -187,7 +188,7 @@ namespace detail template bool sync_queue_base::wait_until_not_empty_or_closed(unique_lock& lk) { - cond_.wait(lk, boost::bind(&sync_queue_base::not_empty_or_closed, boost::ref(*this), boost::ref(lk))); + cond_.wait(lk, boost::bind(&sync_queue_base::not_empty_or_closed, this, boost::ref(lk))); if (! empty(lk)) return false; // success return true; // closed } @@ -196,7 +197,7 @@ namespace detail template queue_op_status sync_queue_base::wait_until_not_empty_or_closed_until(unique_lock& lk, chrono::time_point const&tp) { - if (! cond_.wait_until(lk, tp, boost::bind(&sync_queue_base::not_empty_or_closed, boost::ref(*this), boost::ref(lk)))) + if (! cond_.wait_until(lk, tp, boost::bind(&sync_queue_base::not_empty_or_closed, this, boost::ref(lk)))) return queue_op_status::timeout; if (! empty(lk)) return queue_op_status::success; return queue_op_status::closed; diff --git a/include/boost/thread/detail/thread.hpp b/include/boost/thread/detail/thread.hpp index 3717311060..a1bfe643b1 100644 --- a/include/boost/thread/detail/thread.hpp +++ b/include/boost/thread/detail/thread.hpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include #include @@ -47,6 +46,8 @@ #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #include +#else +#include #endif #include diff --git a/include/boost/thread/experimental/parallel/v2/task_region.hpp b/include/boost/thread/experimental/parallel/v2/task_region.hpp index 02d7b1dacb..b8ec759b1e 100644 --- a/include/boost/thread/experimental/parallel/v2/task_region.hpp +++ b/include/boost/thread/experimental/parallel/v2/task_region.hpp @@ -51,7 +51,7 @@ BOOST_THREAD_INLINE_NAMESPACE(v2) namespace detail { - void handle_task_region_exceptions(exception_list& errors) + inline void handle_task_region_exceptions(exception_list& errors) { try { throw; diff --git a/include/boost/thread/future.hpp b/include/boost/thread/future.hpp index 00f504b9b8..154114aeb6 100644 --- a/include/boost/thread/future.hpp +++ b/include/boost/thread/future.hpp @@ -392,7 +392,7 @@ namespace boost is_deferred_=false; execute(lk); } - waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this))); + waiters.wait(lk, boost::bind(&shared_state_base::is_done, this)); if(rethrow && exception) { boost::rethrow_exception(exception); @@ -419,7 +419,7 @@ namespace boost return false; do_callback(lock); - return waiters.timed_wait(lock, rel_time, boost::bind(&shared_state_base::is_done, boost::ref(*this))); + return waiters.timed_wait(lock, rel_time, boost::bind(&shared_state_base::is_done, this)); } bool timed_wait_until(boost::system_time const& target_time) @@ -429,7 +429,7 @@ namespace boost return false; do_callback(lock); - return waiters.timed_wait(lock, target_time, boost::bind(&shared_state_base::is_done, boost::ref(*this))); + return waiters.timed_wait(lock, target_time, boost::bind(&shared_state_base::is_done, this)); } #endif #ifdef BOOST_THREAD_USES_CHRONO @@ -442,7 +442,7 @@ namespace boost if (is_deferred_) return future_status::deferred; do_callback(lock); - if(!waiters.wait_until(lock, abs_time, boost::bind(&shared_state_base::is_done, boost::ref(*this)))) + if(!waiters.wait_until(lock, abs_time, boost::bind(&shared_state_base::is_done, this))) { return future_status::timeout; } @@ -939,7 +939,7 @@ namespace boost join(); #elif defined BOOST_THREAD_ASYNC_FUTURE_WAITS unique_lock lk(this->mutex); - this->waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this))); + this->waiters.wait(lk, boost::bind(&shared_state_base::is_done, this)); #endif } @@ -4649,32 +4649,34 @@ namespace detail shared_ptr that_; #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) - BOOST_THREAD_COPYABLE_AND_MOVABLE(run_it) - run_it(run_it const& x) //BOOST_NOEXCEPT - : that_(x.that_) - {} - run_it& operator=(BOOST_THREAD_COPY_ASSIGN_REF(run_it) x) //BOOST_NOEXCEPT - { - if (this != &x) { - that_=x.that_; - } - return *this; - } - // move - run_it(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT - : that_(x.that_) - { - x.that_.reset(); + BOOST_THREAD_COPYABLE_AND_MOVABLE(run_it) + run_it(run_it const& x) //BOOST_NOEXCEPT + : that_(x.that_) + {} + run_it& operator=(BOOST_THREAD_COPY_ASSIGN_REF(run_it) x) //BOOST_NOEXCEPT + { + if (this != &x) { + that_=x.that_; } - run_it& operator=(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT { - if (this != &x) { - that_=x.that; - x.that_.reset(); - } - return *this; + return *this; + } + // move + run_it(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT + : that_(boost::move(x.that_)) + { + } + run_it& operator=(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT { + if (this != &x) { + that_ = boost::move(x.that_); } + return *this; + } + run_it(shared_ptr that) : that_(boost::move(that)) + {} +#else + run_it(shared_ptr that) : that_(that) + {} #endif - run_it(shared_ptr that) : that_ (that) {} void operator()() { diff --git a/include/boost/thread/pthread/once.hpp b/include/boost/thread/pthread/once.hpp index 7d66435263..d9eb52eda0 100644 --- a/include/boost/thread/pthread/once.hpp +++ b/include/boost/thread/pthread/once.hpp @@ -19,14 +19,17 @@ #include #include -#include #include -#include - #include #include #include +#if !defined(BOOST_THREAD_PROVIDES_INVOKE) && !defined(BOOST_THREAD_PROVIDES_INVOKE_RET) +#include +#endif + +#include + namespace boost { diff --git a/include/boost/thread/pthread/once_atomic.hpp b/include/boost/thread/pthread/once_atomic.hpp index ce96702ffb..a35c5efd9f 100644 --- a/include/boost/thread/pthread/once_atomic.hpp +++ b/include/boost/thread/pthread/once_atomic.hpp @@ -16,8 +16,12 @@ #include #include #include +#include +#include + +#if !defined(BOOST_THREAD_PROVIDES_INVOKE) && !defined(BOOST_THREAD_PROVIDES_INVOKE_RET) #include -#include +#endif #include diff --git a/include/boost/thread/pthread/pthread_helpers.hpp b/include/boost/thread/pthread/pthread_helpers.hpp index 6809994165..f3447d1fc2 100644 --- a/include/boost/thread/pthread/pthread_helpers.hpp +++ b/include/boost/thread/pthread/pthread_helpers.hpp @@ -9,6 +9,7 @@ #include #include +#include #include #include diff --git a/include/boost/thread/pthread/shared_mutex.hpp b/include/boost/thread/pthread/shared_mutex.hpp index 993e6f2602..d4b828045d 100644 --- a/include/boost/thread/pthread/shared_mutex.hpp +++ b/include/boost/thread/pthread/shared_mutex.hpp @@ -171,7 +171,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - shared_cond.wait(lk, boost::bind(&state_data::can_lock_shared, boost::ref(state))); + shared_cond.wait(lk, boost::bind(&state_data::can_lock_shared, &state)); state.lock_shared(); } @@ -194,7 +194,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_shared, boost::ref(state)))) + if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_shared, &state))) { return false; } @@ -209,7 +209,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_shared, boost::ref(state)))) + if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_shared, &state))) { return false; } @@ -230,7 +230,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_shared, boost::ref(state)))) + if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_shared, &state))) { return false; } @@ -270,7 +270,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.exclusive_waiting_blocked=true; - exclusive_cond.wait(lk, boost::bind(&state_data::can_lock, boost::ref(state))); + exclusive_cond.wait(lk, boost::bind(&state_data::can_lock, &state)); state.exclusive=true; } @@ -282,7 +282,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.exclusive_waiting_blocked=true; - if(!exclusive_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock, boost::ref(state)))) + if(!exclusive_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock, &state))) { state.exclusive_waiting_blocked=false; release_waiters(); @@ -300,7 +300,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.exclusive_waiting_blocked=true; - if(!exclusive_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock, boost::ref(state)))) + if(!exclusive_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock, &state))) { state.exclusive_waiting_blocked=false; release_waiters(); @@ -324,7 +324,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.exclusive_waiting_blocked=true; - if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock, boost::ref(state)))) + if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock, &state))) { state.exclusive_waiting_blocked=false; release_waiters(); @@ -362,7 +362,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - shared_cond.wait(lk, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))); + shared_cond.wait(lk, boost::bind(&state_data::can_lock_upgrade, &state)); state.lock_shared(); state.upgrade=true; } @@ -374,7 +374,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_upgrade, boost::ref(state)))) + if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_upgrade, &state))) { return false; } @@ -390,7 +390,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state)))) + if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_upgrade, &state))) { return false; } @@ -412,7 +412,7 @@ namespace boost boost::this_thread::disable_interruption do_not_disturb; #endif boost::unique_lock lk(state_change); - if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state)))) + if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, &state))) { return false; } @@ -457,7 +457,7 @@ namespace boost boost::unique_lock lk(state_change); state.assert_lock_upgraded(); state.unlock_shared(); - upgrade_cond.wait(lk, boost::bind(&state_data::no_shared, boost::ref(state))); + upgrade_cond.wait(lk, boost::bind(&state_data::no_shared, &state)); state.upgrade=false; state.exclusive=true; state.assert_locked(); @@ -511,7 +511,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.assert_lock_upgraded(); - if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, boost::ref(state)))) + if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, &state))) { return false; } @@ -569,7 +569,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.assert_lock_shared(); - if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, boost::ref(state)))) + if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, &state))) { return false; } @@ -623,7 +623,7 @@ namespace boost #endif boost::unique_lock lk(state_change); state.assert_lock_shared(); - if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state)))) + if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, &state))) { return false; } diff --git a/include/boost/thread/v2/shared_mutex.hpp b/include/boost/thread/v2/shared_mutex.hpp index 8b0cf8ee1f..70ba47daf1 100644 --- a/include/boost/thread/v2/shared_mutex.hpp +++ b/include/boost/thread/v2/shared_mutex.hpp @@ -275,9 +275,9 @@ namespace boost { inline void shared_mutex::lock() { boost::unique_lock lk(mut_); - gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, boost::ref(*this))); + gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, this)); state_ |= write_entered_; - gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, boost::ref(*this))); + gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, this)); } inline bool shared_mutex::try_lock() @@ -298,13 +298,13 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &shared_mutex::no_writer, boost::ref(*this)))) + &shared_mutex::no_writer, this))) { return false; } state_ |= write_entered_; if (!gate2_.wait_until(lk, abs_time, boost::bind( - &shared_mutex::no_readers, boost::ref(*this)))) + &shared_mutex::no_readers, this))) { state_ &= ~write_entered_; return false; @@ -319,13 +319,13 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( - &shared_mutex::no_writer, boost::ref(*this)))) + &shared_mutex::no_writer, this))) { return false; } state_ |= write_entered_; if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind( - &shared_mutex::no_readers, boost::ref(*this)))) + &shared_mutex::no_readers, this))) { state_ &= ~write_entered_; return false; @@ -350,7 +350,7 @@ namespace boost { inline void shared_mutex::lock_shared() { boost::unique_lock lk(mut_); - gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, boost::ref(*this))); + gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, this)); count_t num_readers = (state_ & n_readers_) + 1; state_ &= ~n_readers_; state_ |= num_readers; @@ -376,7 +376,7 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &shared_mutex::no_writer_no_max_readers, boost::ref(*this)))) + &shared_mutex::no_writer_no_max_readers, this))) { return false; } @@ -393,7 +393,7 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( - &shared_mutex::no_writer_no_max_readers, boost::ref(*this)))) + &shared_mutex::no_writer_no_max_readers, this))) { return false; } @@ -653,9 +653,9 @@ namespace boost { inline void upgrade_mutex::lock() { boost::unique_lock lk(mut_); - gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))); + gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, this)); state_ |= write_entered_; - gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this))); + gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, this)); } inline bool upgrade_mutex::try_lock() @@ -676,13 +676,13 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_upgrader, this))) { return false; } state_ |= write_entered_; if (!gate2_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_readers, boost::ref(*this)))) + &upgrade_mutex::no_readers, this))) { state_ &= ~write_entered_; return false; @@ -697,13 +697,13 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( - &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_upgrader, this))) { return false; } state_ |= write_entered_; if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind( - &upgrade_mutex::no_readers, boost::ref(*this)))) + &upgrade_mutex::no_readers, this))) { state_ &= ~write_entered_; return false; @@ -729,7 +729,7 @@ namespace boost { inline void upgrade_mutex::lock_shared() { boost::unique_lock lk(mut_); - gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, boost::ref(*this))); + gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, this)); count_t num_readers = (state_ & n_readers_) + 1; state_ &= ~n_readers_; state_ |= num_readers; @@ -755,7 +755,7 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_max_readers, this))) { return false; } @@ -772,7 +772,7 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( - &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_max_readers, this))) { return false; } @@ -807,7 +807,7 @@ namespace boost { inline void upgrade_mutex::lock_upgrade() { boost::unique_lock lk(mut_); - gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this))); + gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, this)); count_t num_readers = (state_ & n_readers_) + 1; state_ &= ~n_readers_; state_ |= upgradable_entered_ | num_readers; @@ -833,7 +833,7 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_upgrader_no_max_readers, this))) { return false; } @@ -850,7 +850,7 @@ namespace boost { { boost::unique_lock lk(mut_); if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( - &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_upgrader_no_max_readers, this))) { return false; } @@ -898,7 +898,7 @@ namespace boost { boost::unique_lock lk(mut_); BOOST_ASSERT(one_or_more_readers()); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_upgrader, this))) { return false; } @@ -906,7 +906,7 @@ namespace boost { state_ &= ~n_readers_; state_ |= (write_entered_ | num_readers); if (!gate2_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_readers, boost::ref(*this)))) + &upgrade_mutex::no_readers, this))) { ++num_readers; state_ &= ~(write_entered_ | n_readers_); @@ -953,7 +953,7 @@ namespace boost { boost::unique_lock lk(mut_); BOOST_ASSERT(one_or_more_readers()); if (!gate1_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) + &upgrade_mutex::no_writer_no_upgrader, this))) { return false; } @@ -987,7 +987,7 @@ namespace boost { count_t num_readers = (state_ & n_readers_) - 1; state_ &= ~(upgradable_entered_ | n_readers_); state_ |= write_entered_ | num_readers; - gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this))); + gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, this)); } inline bool upgrade_mutex::try_unlock_upgrade_and_lock() @@ -1017,7 +1017,7 @@ namespace boost { state_ &= ~(upgradable_entered_ | n_readers_); state_ |= (write_entered_ | num_readers); if (!gate2_.wait_until(lk, abs_time, boost::bind( - &upgrade_mutex::no_readers, boost::ref(*this)))) + &upgrade_mutex::no_readers, this))) { ++num_readers; state_ &= ~(write_entered_ | n_readers_); diff --git a/include/boost/thread/win32/once.hpp b/include/boost/thread/win32/once.hpp index 5625dbc1bf..f5850bdebb 100644 --- a/include/boost/thread/win32/once.hpp +++ b/include/boost/thread/win32/once.hpp @@ -22,7 +22,9 @@ #include #include +#if !defined(BOOST_THREAD_PROVIDES_INVOKE) && !defined(BOOST_THREAD_PROVIDES_INVOKE_RET) #include +#endif #include @@ -152,7 +154,7 @@ namespace boost { name_once_mutex(mutex_name,flag_address); } - + return ::boost::detail::win32::create_event( mutex_name, ::boost::detail::win32::manual_reset_event, diff --git a/src/pthread/once_atomic.cpp b/src/pthread/once_atomic.cpp index 69f5be8098..5f480a4c66 100644 --- a/src/pthread/once_atomic.cpp +++ b/src/pthread/once_atomic.cpp @@ -11,8 +11,8 @@ #include #include #include -#include #include +#include #include namespace boost diff --git a/src/pthread/thread.cpp b/src/pthread/thread.cpp index bcaa787071..9deef7a2fb 100644 --- a/src/pthread/thread.cpp +++ b/src/pthread/thread.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #ifdef __GLIBC__ #include @@ -185,7 +186,7 @@ namespace boost // Unhandled exceptions still cause the application to terminate // BOOST_CATCH(...) // { -// throw; +// throw; // // std::terminate(); // } @@ -212,12 +213,13 @@ namespace boost interrupt_enabled=false; #endif } - ~externally_launched_thread() { - BOOST_ASSERT(notify.empty()); - notify.clear(); + ~externally_launched_thread() + { + BOOST_ASSERT(notify.empty()); + notify.clear(); //#ifndef BOOST_NO_EXCEPTIONS - BOOST_ASSERT(async_states_.empty()); - async_states_.clear(); + BOOST_ASSERT(async_states_.empty()); + async_states_.clear(); //#endif } void run() @@ -354,7 +356,7 @@ namespace boost } else { - return false; + return false; } } @@ -373,8 +375,8 @@ namespace boost } if(!local_thread_info->done) { - res=false; - return true; + res=false; + return true; } do_join=!local_thread_info->join_started; @@ -437,31 +439,31 @@ namespace boost namespace this_thread { - namespace no_interruption_point - { - namespace hidden + namespace no_interruption_point { - void BOOST_THREAD_DECL sleep_for_internal(const detail::platform_duration& ts) - { - if (ts > detail::platform_duration::zero()) + namespace hidden + { + void BOOST_THREAD_DECL sleep_for_internal(const detail::platform_duration& ts) { - // Use pthread_delay_np or nanosleep whenever possible here in the no_interruption_point - // namespace because they do not provide an interruption point. - # if defined(BOOST_HAS_PTHREAD_DELAY_NP) - # if defined(__IBMCPP__) || defined(_AIX) - BOOST_VERIFY(!pthread_delay_np(const_cast(&ts.getTs()))); - # else - BOOST_VERIFY(!pthread_delay_np(&ts.getTs())); - # endif - # elif defined(BOOST_HAS_NANOSLEEP) - nanosleep(&ts.getTs(), 0); - # else - // This should never be reached due to BOOST_THREAD_SLEEP_FOR_IS_STEADY - # endif + if (ts > detail::platform_duration::zero()) + { + // Use pthread_delay_np or nanosleep whenever possible here in the no_interruption_point + // namespace because they do not provide an interruption point. +# if defined(BOOST_HAS_PTHREAD_DELAY_NP) +# if defined(__IBMCPP__) || defined(_AIX) + BOOST_VERIFY(!pthread_delay_np(const_cast(&ts.getTs()))); +# else + BOOST_VERIFY(!pthread_delay_np(&ts.getTs())); +# endif +# elif defined(BOOST_HAS_NANOSLEEP) + nanosleep(&ts.getTs(), 0); +# else + // This should never be reached due to BOOST_THREAD_SLEEP_FOR_IS_STEADY +# endif + } } - } + } } - } void yield() BOOST_NOEXCEPT { @@ -515,7 +517,7 @@ namespace boost unsigned thread::physical_concurrency() BOOST_NOEXCEPT { #ifdef __linux__ - try { + BOOST_TRY { using namespace std; ifstream proc_cpuinfo ("/proc/cpuinfo"); @@ -570,9 +572,10 @@ namespace boost // Fall back to hardware_concurrency() in case // /proc/cpuinfo is formatted differently than we expect. return cores.size() != 0 ? cores.size() : hardware_concurrency(); - } catch(...) { - return hardware_concurrency(); + } BOOST_CATCH(...) { + return hardware_concurrency(); } + BOOST_CATCH_END #elif defined(__APPLE__) int count; size_t size=sizeof(count); @@ -786,26 +789,25 @@ namespace boost BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock lk) { - detail::thread_data_base* const current_thread_data(detail::get_current_thread_data()); - if(current_thread_data) - { - current_thread_data->notify_all_at_thread_exit(&cond, lk.release()); - } + detail::thread_data_base* const current_thread_data(detail::get_current_thread_data()); + if(current_thread_data) + { + current_thread_data->notify_all_at_thread_exit(&cond, lk.release()); + } } //#ifndef BOOST_NO_EXCEPTIONS -namespace detail { - +namespace detail +{ void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr as) { - detail::thread_data_base* const current_thread_data(detail::get_current_thread_data()); - if(current_thread_data) - { - current_thread_data->make_ready_at_thread_exit(as); - } + detail::thread_data_base* const current_thread_data(detail::get_current_thread_data()); + if(current_thread_data) + { + current_thread_data->make_ready_at_thread_exit(as); + } } } //#endif - } diff --git a/src/win32/thread.cpp b/src/win32/thread.cpp index 000ab8779d..996cb40be9 100644 --- a/src/win32/thread.cpp +++ b/src/win32/thread.cpp @@ -29,15 +29,16 @@ #include #include #include +#include #if BOOST_PLAT_WINDOWS_RUNTIME #include #include #include -#include -#include -#include -#include +#include +#include +#include +#include #include #pragma comment(lib, "runtimeobject.lib") #endif @@ -577,10 +578,18 @@ namespace boost } Reason; } REASON_CONTEXT, *PREASON_CONTEXT; typedef BOOL (WINAPI *setwaitabletimerex_t)(HANDLE, const LARGE_INTEGER *, LONG, PTIMERAPCROUTINE, LPVOID, PREASON_CONTEXT, ULONG); +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable: 4100) // unreferenced formal parameter +#endif static inline BOOL WINAPI SetWaitableTimerEx_emulation(HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext, ULONG TolerableDelay) { return SetWaitableTimer(hTimer, lpDueTime, lPeriod, pfnCompletionRoutine, lpArgToCompletionRoutine, FALSE); } +#ifdef _MSC_VER +#pragma warning(pop) +#endif + #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable: 6387) // MSVC sanitiser warns that GetModuleHandleA() might fail diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 3f81bc07e8..511977a03f 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -110,18 +110,18 @@ project msvc:/wd6246 ; -rule thread-run ( sources ) +rule thread-run ( sources : reqs * ) { sources = $(sources) winrt_init.cpp ; return - [ run $(sources) ../build//boost_thread ] + [ run $(sources) ../build//boost_thread : : : $(reqs) ] [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/static - : : : : $(sources[1]:B)_lib ] + : : : $(reqs) : $(sources[1]:B)_lib ] ; } -rule thread-test ( sources ) +rule thread-test ( sources : reqs * ) { sources = $(sources) winrt_init.cpp ; return @@ -136,14 +136,14 @@ rule thread-test ( sources ) ; } -rule thread-run2 ( sources : name ) +rule thread-run2 ( sources : name : reqs * ) { sources = $(sources) winrt_init.cpp ; return - [ run $(sources) ../build//boost_thread : : : + [ run $(sources) ../build//boost_thread : : : $(reqs) : $(name) ] [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/static - : : : + : : : $(reqs) : $(name)_lib ] ; } @@ -268,16 +268,15 @@ rule generate_self_contained_header_tests if ! [ os.environ BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS ] { - local headers_path = [ path.make $(BOOST_ROOT)/libs/thread/include/boost/thread ] ; - for file in [ path.glob-tree $(headers_path) : *.hpp : detail pthread win32 ] + for file in [ glob-tree-ex ../include/boost/thread : *.hpp : detail pthread win32 ] { - local rel_file = [ path.relative-to $(headers_path) $(file) ] ; + local rel_file = [ path.relative-to ../include/boost/thread $(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 ~hdr/$(rel_file) "/" "-" ] ; #ECHO $(rel_file) ; - all_rules += [ compile self_contained_header.cpp : "BOOST_THREAD_TEST_HEADER=$(rel_file)" $(file) : $(test_name) ] ; - all_rules += [ compile self_contained_header.cpp : "BOOST_THREAD_TEST_HEADER=$(rel_file)" "BOOST_THREAD_TEST_POST_WINDOWS_H" $(file) @windows-cygwin-specific : $(test_name)-post_winh ] ; + all_rules += [ compile self_contained_header.cpp : "BOOST_THREAD_TEST_HEADER=$(rel_file)" $(file) ../build//boost_thread : $(test_name) ] ; + all_rules += [ compile self_contained_header.cpp : "BOOST_THREAD_TEST_HEADER=$(rel_file)" "BOOST_THREAD_TEST_POST_WINDOWS_H" $(file) @windows-cygwin-specific ../build//boost_thread : $(test_name)-post_winh ] ; } } @@ -363,7 +362,10 @@ rule generate_self_contained_header_tests [ thread-run test_7571.cpp ] [ thread-run test_9319.cpp ] #[ thread-run test_9711.cpp ] This is an invalid use of ::then deferred. - [ thread-run test_9856.cpp ] + [ thread-run test_9856.cpp : + gcc:-fopenmp + gcc:-fopenmp + ] [ thread-compile test_10963.cpp : : test_10963_c ] [ thread-run test_10964.cpp ] [ thread-test test_11053.cpp ] @@ -1012,7 +1014,7 @@ rule generate_self_contained_header_tests #[ thread-run test_10128.cpp ] #[ thread-run test_10340.cpp ] ; - + explicit ts_more_cpp11 ; test-suite ts_more_cpp11 : @@ -1033,13 +1035,13 @@ rule generate_self_contained_header_tests : [ thread-run2-noit ./experimental/parallel/v1/exception_list_pass.cpp : exception_list_p ] ; - + #explicit ts_task_region ; test-suite ts_task_region : [ thread-run2-noit ./experimental/parallel/v2/task_region_pass.cpp : task_region_p ] ; - + explicit ts_other ; test-suite ts_other : @@ -1050,7 +1052,7 @@ rule generate_self_contained_header_tests explicit ts_ ; test-suite ts_ : - #[ thread-run test_11256.cpp ] + #[ thread-run test_11256.cpp ] #[ thread-run test_11256.cpp ] #[ thread-run test_11499.cpp ] #[ thread-run test_11611.cpp ] @@ -1060,7 +1062,7 @@ rule generate_self_contained_header_tests #[ thread-run test_12949.cpp ] #[ thread-run test_13480b.cpp ] [ thread-run test_13561.cpp ] - + ; explicit test_time_jumps_1_obj ; diff --git a/test/condition_test_common.hpp b/test/condition_test_common.hpp index 4aa114e050..2e359c5c09 100644 --- a/test/condition_test_common.hpp +++ b/test/condition_test_common.hpp @@ -30,12 +30,16 @@ struct wait_for_flag flag(flag_) {} + check_flag(check_flag const& that): + flag(that.flag) + {} + bool operator()() const { return flag; } private: - void operator=(check_flag&); + check_flag& operator=(check_flag const&); }; diff --git a/test/experimental/parallel/v1/exception_list_pass.cpp b/test/experimental/parallel/v1/exception_list_pass.cpp index de79412ae5..cc1a45f15f 100644 --- a/test/experimental/parallel/v1/exception_list_pass.cpp +++ b/test/experimental/parallel/v1/exception_list_pass.cpp @@ -14,7 +14,7 @@ #include -#include +#include int main() diff --git a/test/experimental/parallel/v2/task_region_pass.cpp b/test/experimental/parallel/v2/task_region_pass.cpp index 814ef28e5b..1ee8437f7f 100644 --- a/test/experimental/parallel/v2/task_region_pass.cpp +++ b/test/experimental/parallel/v2/task_region_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #if ! defined BOOST_NO_CXX11_LAMBDAS && defined(BOOST_THREAD_PROVIDES_INVOKE) using boost::experimental::parallel::v2::task_region; diff --git a/test/functional/invoke/invoke_int_0_pass.cpp b/test/functional/invoke/invoke_int_0_pass.cpp index fa1f675439..afadb60cda 100644 --- a/test/functional/invoke/invoke_int_0_pass.cpp +++ b/test/functional/invoke/invoke_int_0_pass.cpp @@ -15,7 +15,7 @@ // #include -#include +#include int f() { diff --git a/test/functional/invoke/invoke_lvalue_pass.cpp b/test/functional/invoke/invoke_lvalue_pass.cpp index 154953d891..ee1adb0554 100644 --- a/test/functional/invoke/invoke_lvalue_pass.cpp +++ b/test/functional/invoke/invoke_lvalue_pass.cpp @@ -16,7 +16,7 @@ // #include -#include +#include int count = 0; diff --git a/test/functional/invoke/invoke_rvalue_pass.cpp b/test/functional/invoke/invoke_rvalue_pass.cpp index 82ea094326..85d5d89b96 100644 --- a/test/functional/invoke/invoke_rvalue_pass.cpp +++ b/test/functional/invoke/invoke_rvalue_pass.cpp @@ -15,7 +15,7 @@ // #include -#include +#include int count = 0; diff --git a/test/functional/invoker/invoker_int_0_pass.cpp b/test/functional/invoker/invoker_int_0_pass.cpp index 123bde2e6a..f0194078c4 100644 --- a/test/functional/invoker/invoker_int_0_pass.cpp +++ b/test/functional/invoker/invoker_int_0_pass.cpp @@ -15,7 +15,7 @@ // #include -#include +#include int f() { diff --git a/test/functional/invoker/invoker_lvalue_pass.cpp b/test/functional/invoker/invoker_lvalue_pass.cpp index 42a98d45a1..d1a6acaad0 100644 --- a/test/functional/invoker/invoker_lvalue_pass.cpp +++ b/test/functional/invoker/invoker_lvalue_pass.cpp @@ -15,7 +15,7 @@ // #include -#include +#include int count = 0; diff --git a/test/functional/invoker/invoker_rvalue_pass.cpp b/test/functional/invoker/invoker_rvalue_pass.cpp index ae06e16b62..55139efd48 100644 --- a/test/functional/invoker/invoker_rvalue_pass.cpp +++ b/test/functional/invoker/invoker_rvalue_pass.cpp @@ -19,7 +19,7 @@ #endif #include -#include +#include int count = 0; diff --git a/test/sync/conditions/condition_variable/copy_fail.cpp b/test/sync/conditions/condition_variable/copy_fail.cpp index 374ce31652..58dd5b9794 100644 --- a/test/sync/conditions/condition_variable/copy_fail.cpp +++ b/test/sync/conditions/condition_variable/copy_fail.cpp @@ -18,7 +18,7 @@ // condition_variable(const condition_variable&) = delete; #include -#include +#include void fail() { diff --git a/test/sync/conditions/condition_variable/default_pass.cpp b/test/sync/conditions/condition_variable/default_pass.cpp index 465a12de86..4842355daa 100644 --- a/test/sync/conditions/condition_variable/default_pass.cpp +++ b/test/sync/conditions/condition_variable/default_pass.cpp @@ -18,7 +18,7 @@ // condition_variable(const condition_variable&) = delete; #include -#include +#include int main() { diff --git a/test/sync/conditions/condition_variable/dtor_pass.cpp b/test/sync/conditions/condition_variable/dtor_pass.cpp index 533898ed46..0fc4f4a03d 100644 --- a/test/sync/conditions/condition_variable/dtor_pass.cpp +++ b/test/sync/conditions/condition_variable/dtor_pass.cpp @@ -21,10 +21,10 @@ #include #include #include -#include +#include -boost::condition_variable* cv; -boost::mutex m; +boost::condition_variable* g_cv; +boost::mutex g_mutex; typedef boost::unique_lock Lock; bool f_ready = false; @@ -32,33 +32,33 @@ bool g_ready = false; void f() { - Lock lk(m); + Lock lk(g_mutex); f_ready = true; - cv->notify_one(); - cv->wait(lk); - delete cv; + g_cv->notify_one(); + g_cv->wait(lk); + delete g_cv; } void g() { - Lock lk(m); + Lock lk(g_mutex); g_ready = true; - cv->notify_one(); + g_cv->notify_one(); while (!f_ready) { - cv->wait(lk); + g_cv->wait(lk); } - cv->notify_one(); + g_cv->notify_one(); } int main() { - cv = new boost::condition_variable; + g_cv = new boost::condition_variable; boost::thread th2(g); - Lock lk(m); + Lock lk(g_mutex); while (!g_ready) { - cv->wait(lk); + g_cv->wait(lk); } lk.unlock(); boost::thread th1(f); diff --git a/test/sync/conditions/condition_variable/lost_notif_pass.cpp b/test/sync/conditions/condition_variable/lost_notif_pass.cpp index 79dbcd2956..8b54c82843 100644 --- a/test/sync/conditions/condition_variable/lost_notif_pass.cpp +++ b/test/sync/conditions/condition_variable/lost_notif_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include // Summary of each test: @@ -60,7 +60,7 @@ bool threadIsWaiting() #ifdef BOOST_THREAD_USES_DATETIME -boost::posix_time::milliseconds posix_wait_time(1000); +boost::posix_time::milliseconds posix_wait_time(2000); template void test_posix_wait_function(F f) @@ -68,12 +68,14 @@ void test_posix_wait_function(F f) flag = false; waiting = false; boost::thread t(f); + boost::unique_lock lk(mut); while (!threadIsWaiting()) { - boost::this_thread::sleep(boost::posix_time::milliseconds(1)); + lk.unlock(); + boost::this_thread::sleep(boost::posix_time::milliseconds(10)); + lk.lock(); } - boost::unique_lock lk(mut); boost::this_thread::sleep(boost::posix_time::milliseconds(500)); boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::universal_time(); flag = true; @@ -82,7 +84,7 @@ void test_posix_wait_function(F f) t.join(); boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::universal_time(); - BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(250)); + BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(500)); } //------------------------------------------------------------------------------ @@ -131,7 +133,7 @@ void timed_wait_relative_with_pred() #ifdef BOOST_THREAD_USES_CHRONO -boost::chrono::milliseconds chrono_wait_time(1000); +boost::chrono::milliseconds chrono_wait_time(2000); template void test_chrono_wait_function(F f) @@ -139,12 +141,14 @@ void test_chrono_wait_function(F f) flag = false; waiting = false; boost::thread t(f); + boost::unique_lock lk(mut); while (!threadIsWaiting()) { - boost::this_thread::sleep_for(boost::chrono::milliseconds(1)); + lk.unlock(); + boost::this_thread::sleep_for(boost::chrono::milliseconds(10)); + lk.lock(); } - boost::unique_lock lk(mut); boost::this_thread::sleep_for(boost::chrono::milliseconds(500)); boost::chrono::steady_clock::time_point t0 = boost::chrono::steady_clock::now(); flag = true; @@ -153,7 +157,7 @@ void test_chrono_wait_function(F f) t.join(); boost::chrono::steady_clock::time_point t1 = boost::chrono::steady_clock::now(); - BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(250)); + BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(500)); } //------------------------------------------------------------------------------ diff --git a/test/sync/conditions/condition_variable/native_handle_pass.cpp b/test/sync/conditions/condition_variable/native_handle_pass.cpp index 9835f5920f..51a4130d87 100644 --- a/test/sync/conditions/condition_variable/native_handle_pass.cpp +++ b/test/sync/conditions/condition_variable/native_handle_pass.cpp @@ -20,7 +20,8 @@ #include #include -#include +#include +#include int main() { diff --git a/test/sync/conditions/condition_variable/wait_for_pass.cpp b/test/sync/conditions/condition_variable/wait_for_pass.cpp index 4c6a0af3ec..d6dd519a74 100644 --- a/test/sync/conditions/condition_variable/wait_for_pass.cpp +++ b/test/sync/conditions/condition_variable/wait_for_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include "../../../timming.hpp" diff --git a/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp b/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp index 92ba82f1ed..cf2bcfd5f7 100644 --- a/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp +++ b/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp @@ -20,7 +20,8 @@ #include #include #include -#include +#include +#include #include #include #include "../../../timming.hpp" @@ -55,7 +56,7 @@ typedef boost::chrono::milliseconds milliseconds; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -const ms max_diff(BOOST_THREAD_TEST_TIME_MS); +BOOST_ATTRIBUTE_UNUSED const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { @@ -64,9 +65,11 @@ void f() assert(test2 == 0); test1 = 1; cv.notify_one(); - Clock::time_point t0 = Clock::now(); + BOOST_ATTRIBUTE_UNUSED Clock::time_point t0 = Clock::now(); cv.wait_for(lk, milliseconds(250), Pred(test2)); - Clock::time_point t1 = Clock::now(); + BOOST_ATTRIBUTE_UNUSED Clock::time_point t1 = Clock::now(); + (void)t0; + (void)t1; if (runs == 0) { assert(t1 - t0 < max_diff); diff --git a/test/sync/conditions/condition_variable/wait_pass.cpp b/test/sync/conditions/condition_variable/wait_pass.cpp index 612724b857..1438ee4ae6 100644 --- a/test/sync/conditions/condition_variable/wait_pass.cpp +++ b/test/sync/conditions/condition_variable/wait_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include diff --git a/test/sync/conditions/condition_variable/wait_until_pass.cpp b/test/sync/conditions/condition_variable/wait_until_pass.cpp index 34ef322684..cafd66b22e 100644 --- a/test/sync/conditions/condition_variable/wait_until_pass.cpp +++ b/test/sync/conditions/condition_variable/wait_until_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include #include "../../../timming.hpp" diff --git a/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp b/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp index 120e49853f..dd1c540c50 100644 --- a/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp +++ b/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp @@ -20,7 +20,8 @@ #include #include #include -#include +#include +#include #include #include #include "../../../timming.hpp" @@ -79,8 +80,9 @@ void f() cv.notify_one(); Clock::time_point t0 = Clock::now(); Clock::time_point t = t0 + Clock::duration(250); - bool r = cv.wait_until(lk, t, Pred(test2)); + BOOST_ATTRIBUTE_UNUSED bool r = cv.wait_until(lk, t, Pred(test2)); Clock::time_point t1 = Clock::now(); + (void)r; if (runs == 0) { assert(t1 - t0 < max_diff); diff --git a/test/sync/conditions/condition_variable_any/copy_fail.cpp b/test/sync/conditions/condition_variable_any/copy_fail.cpp index 71d3a3f06e..2b21d7013e 100644 --- a/test/sync/conditions/condition_variable_any/copy_fail.cpp +++ b/test/sync/conditions/condition_variable_any/copy_fail.cpp @@ -18,7 +18,7 @@ // condition_variable_any(const condition_variable_any&) = delete; #include -#include +#include void fail() { diff --git a/test/sync/conditions/condition_variable_any/default_pass.cpp b/test/sync/conditions/condition_variable_any/default_pass.cpp index 21116ebc48..fdbc6dc8ed 100644 --- a/test/sync/conditions/condition_variable_any/default_pass.cpp +++ b/test/sync/conditions/condition_variable_any/default_pass.cpp @@ -18,7 +18,7 @@ // condition_variable_any(const condition_variable_any&) = delete; #include -#include +#include int main() { diff --git a/test/sync/conditions/condition_variable_any/dtor_pass.cpp b/test/sync/conditions/condition_variable_any/dtor_pass.cpp index 7734d93b74..228723e412 100644 --- a/test/sync/conditions/condition_variable_any/dtor_pass.cpp +++ b/test/sync/conditions/condition_variable_any/dtor_pass.cpp @@ -21,10 +21,10 @@ #include #include #include -#include +#include -boost::condition_variable_any* cv; -boost::timed_mutex m; +boost::condition_variable_any* g_cv; +boost::timed_mutex g_mutex; typedef boost::unique_lock Lock; bool f_ready = false; @@ -32,33 +32,33 @@ bool g_ready = false; void f() { - Lock lk(m); + Lock lk(g_mutex); f_ready = true; - cv->notify_one(); - cv->wait(lk); - delete cv; + g_cv->notify_one(); + g_cv->wait(lk); + delete g_cv; } void g() { - Lock lk(m); + Lock lk(g_mutex); g_ready = true; - cv->notify_one(); + g_cv->notify_one(); while (!f_ready) { - cv->wait(lk); + g_cv->wait(lk); } - cv->notify_one(); + g_cv->notify_one(); } int main() { - cv = new boost::condition_variable_any; + g_cv = new boost::condition_variable_any; boost::thread th2(g); - Lock lk(m); + Lock lk(g_mutex); while (!g_ready) { - cv->wait(lk); + g_cv->wait(lk); } lk.unlock(); boost::thread th1(f); diff --git a/test/sync/conditions/condition_variable_any/lost_notif_pass.cpp b/test/sync/conditions/condition_variable_any/lost_notif_pass.cpp index c696da3c24..d4fc7b8ade 100644 --- a/test/sync/conditions/condition_variable_any/lost_notif_pass.cpp +++ b/test/sync/conditions/condition_variable_any/lost_notif_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include // Summary of each test: @@ -60,7 +60,7 @@ bool threadIsWaiting() #ifdef BOOST_THREAD_USES_DATETIME -boost::posix_time::milliseconds posix_wait_time(1000); +boost::posix_time::milliseconds posix_wait_time(2000); template void test_posix_wait_function(F f) @@ -68,12 +68,14 @@ void test_posix_wait_function(F f) flag = false; waiting = false; boost::thread t(f); + boost::unique_lock lk(mut); while (!threadIsWaiting()) { - boost::this_thread::sleep(boost::posix_time::milliseconds(1)); + lk.unlock(); + boost::this_thread::sleep(boost::posix_time::milliseconds(10)); + lk.lock(); } - boost::unique_lock lk(mut); boost::this_thread::sleep(boost::posix_time::milliseconds(500)); boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::universal_time(); flag = true; @@ -82,7 +84,7 @@ void test_posix_wait_function(F f) t.join(); boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::universal_time(); - BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(250)); + BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(500)); } //------------------------------------------------------------------------------ @@ -131,7 +133,7 @@ void timed_wait_relative_with_pred() #ifdef BOOST_THREAD_USES_CHRONO -boost::chrono::milliseconds chrono_wait_time(1000); +boost::chrono::milliseconds chrono_wait_time(2000); template void test_chrono_wait_function(F f) @@ -139,12 +141,14 @@ void test_chrono_wait_function(F f) flag = false; waiting = false; boost::thread t(f); + boost::unique_lock lk(mut); while (!threadIsWaiting()) { - boost::this_thread::sleep_for(boost::chrono::milliseconds(1)); + lk.unlock(); + boost::this_thread::sleep_for(boost::chrono::milliseconds(10)); + lk.lock(); } - boost::unique_lock lk(mut); boost::this_thread::sleep_for(boost::chrono::milliseconds(500)); boost::chrono::steady_clock::time_point t0 = boost::chrono::steady_clock::now(); flag = true; @@ -153,7 +157,7 @@ void test_chrono_wait_function(F f) t.join(); boost::chrono::steady_clock::time_point t1 = boost::chrono::steady_clock::now(); - BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(250)); + BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(500)); } //------------------------------------------------------------------------------ diff --git a/test/sync/conditions/condition_variable_any/wait_for_pass.cpp b/test/sync/conditions/condition_variable_any/wait_for_pass.cpp index b1fca89f68..365badb477 100644 --- a/test/sync/conditions/condition_variable_any/wait_for_pass.cpp +++ b/test/sync/conditions/condition_variable_any/wait_for_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp b/test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp index 3885b23c12..9fd43a2f80 100644 --- a/test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp +++ b/test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/conditions/condition_variable_any/wait_until_pass.cpp b/test/sync/conditions/condition_variable_any/wait_until_pass.cpp index acf5fb1c42..a65d7af669 100644 --- a/test/sync/conditions/condition_variable_any/wait_until_pass.cpp +++ b/test/sync/conditions/condition_variable_any/wait_until_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp b/test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp index f6e9b7ee24..55dffa7945 100644 --- a/test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp +++ b/test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/conditions/cv_status/cv_status_pass.cpp b/test/sync/conditions/cv_status/cv_status_pass.cpp index becac4da5e..8413da6215 100644 --- a/test/sync/conditions/cv_status/cv_status_pass.cpp +++ b/test/sync/conditions/cv_status/cv_status_pass.cpp @@ -18,7 +18,7 @@ // static unsigned hardware_concurrency(); #include -#include +#include int main() { diff --git a/test/sync/conditions/notify_all_at_thread_exit_pass.cpp b/test/sync/conditions/notify_all_at_thread_exit_pass.cpp index d6eecbd95b..a99c093d26 100644 --- a/test/sync/conditions/notify_all_at_thread_exit_pass.cpp +++ b/test/sync/conditions/notify_all_at_thread_exit_pass.cpp @@ -23,7 +23,7 @@ #include #include #include -#include +#include boost::condition_variable cv; boost::mutex mut; diff --git a/test/sync/futures/async/async_executor_pass.cpp b/test/sync/futures/async/async_executor_pass.cpp index d5a0f4423c..6ab1fae850 100644 --- a/test/sync/futures/async/async_executor_pass.cpp +++ b/test/sync/futures/async/async_executor_pass.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include #include @@ -106,12 +106,12 @@ int f0() return 3; } -int i = 0; +int g_i = 0; int& f1() { boost::this_thread::sleep_for(ms(200)); - return i; + return g_i; } void f2() diff --git a/test/sync/futures/async/async_pass.cpp b/test/sync/futures/async/async_pass.cpp index 86fdfdbec6..a287300e3b 100644 --- a/test/sync/futures/async/async_pass.cpp +++ b/test/sync/futures/async/async_pass.cpp @@ -34,7 +34,7 @@ #include #include #include -#include +#include typedef boost::chrono::high_resolution_clock Clock; typedef boost::chrono::milliseconds ms; @@ -109,12 +109,12 @@ int f0() return 3; } -int i = 0; +int g_i = 0; int& f1() { boost::this_thread::sleep_for(ms(200)); - return i; + return g_i; } void f2() @@ -153,8 +153,8 @@ struct check_timer { boost::chrono::nanoseconds delay; Clock::time_point start; check_timer(boost::chrono::nanoseconds delay) - : delay(delay) - , start(Clock::now()) + : delay(delay) + , start(Clock::now()) { } ~check_timer() { @@ -490,7 +490,7 @@ int main() check_timer timer(ms(500)); res = &f.get(); } - BOOST_TEST(res == &i); + BOOST_TEST(res == &g_i); } catch (std::exception& ex) { @@ -513,7 +513,7 @@ int main() check_timer timer(ms(500)); res = &f.get(); } - BOOST_TEST(res == &i); + BOOST_TEST(res == &g_i); } catch (std::exception& ex) { @@ -536,7 +536,7 @@ int main() check_timer timer(ms(500)); res = &f.get(); } - BOOST_TEST(res == &i); + BOOST_TEST(res == &g_i); } catch (std::exception& ex) { @@ -560,7 +560,7 @@ int main() check_timer timer(ms(500)); res = &f.get(); } - BOOST_TEST(res == &i); + BOOST_TEST(res == &g_i); } catch (std::exception& ex) { diff --git a/test/sync/futures/future/async_deferred_then_pass.cpp b/test/sync/futures/future/async_deferred_then_pass.cpp index b400074cdd..7749b3a6a2 100644 --- a/test/sync/futures/future/async_deferred_then_pass.cpp +++ b/test/sync/futures/future/async_deferred_then_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) diff --git a/test/sync/futures/future/copy_assign_fail.cpp b/test/sync/futures/future/copy_assign_fail.cpp index 170f3a0575..90d537fe87 100644 --- a/test/sync/futures/future/copy_assign_fail.cpp +++ b/test/sync/futures/future/copy_assign_fail.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/future/copy_ctor_fail.cpp b/test/sync/futures/future/copy_ctor_fail.cpp index 3a16afd500..8c7d2c2b17 100644 --- a/test/sync/futures/future/copy_ctor_fail.cpp +++ b/test/sync/futures/future/copy_ctor_fail.cpp @@ -20,7 +20,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/future/default_pass.cpp b/test/sync/futures/future/default_pass.cpp index 1b4cf392f6..d33e289ec5 100644 --- a/test/sync/futures/future/default_pass.cpp +++ b/test/sync/futures/future/default_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/future/dtor_pass.cpp b/test/sync/futures/future/dtor_pass.cpp index abfca7d8c6..3e2c86551e 100644 --- a/test/sync/futures/future/dtor_pass.cpp +++ b/test/sync/futures/future/dtor_pass.cpp @@ -22,7 +22,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #include "../test_allocator.hpp" #endif diff --git a/test/sync/futures/future/get_or_pass.cpp b/test/sync/futures/future/get_or_pass.cpp index 95c9fc184c..dd2040d878 100644 --- a/test/sync/futures/future/get_or_pass.cpp +++ b/test/sync/futures/future/get_or_pass.cpp @@ -18,7 +18,7 @@ #include #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO @@ -51,13 +51,13 @@ void func2(boost::promise p) p.set_exception(::make_exception_ptr(3)); } -int j = 0; +int g_j = 0; void func3(boost::promise p) { boost::this_thread::sleep_for(boost::chrono::milliseconds(500)); - j = 5; - p.set_value(j); + g_j = 5; + p.set_value(g_j); } void func4(boost::promise p) diff --git a/test/sync/futures/future/get_pass.cpp b/test/sync/futures/future/get_pass.cpp index 83b3b791c2..1d865b795a 100644 --- a/test/sync/futures/future/get_pass.cpp +++ b/test/sync/futures/future/get_pass.cpp @@ -28,7 +28,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO @@ -61,13 +61,13 @@ void func2(boost::promise p) p.set_exception(::make_exception_ptr(3)); } -int j = 0; +int g_j = 0; void func3(boost::promise p) { boost::this_thread::sleep_for(boost::chrono::milliseconds(500)); - j = 5; - p.set_value(j); + g_j = 5; + p.set_value(g_j); } void func4(boost::promise p) diff --git a/test/sync/futures/future/move_assign_pass.cpp b/test/sync/futures/future/move_assign_pass.cpp index ebb13e5e0f..86851efe9c 100644 --- a/test/sync/futures/future/move_assign_pass.cpp +++ b/test/sync/futures/future/move_assign_pass.cpp @@ -21,10 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include - -boost::mutex m0; -boost::mutex m1; +#include int main() { diff --git a/test/sync/futures/future/move_ctor_pass.cpp b/test/sync/futures/future/move_ctor_pass.cpp index 8da893a3c5..6d1748419d 100644 --- a/test/sync/futures/future/move_ctor_pass.cpp +++ b/test/sync/futures/future/move_ctor_pass.cpp @@ -21,9 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include - -boost::mutex m; +#include int main() { @@ -75,4 +73,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/futures/future/share_pass.cpp b/test/sync/futures/future/share_pass.cpp index 91c07f5cd1..07176efed4 100644 --- a/test/sync/futures/future/share_pass.cpp +++ b/test/sync/futures/future/share_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/future/then_deferred_pass.cpp b/test/sync/futures/future/then_deferred_pass.cpp index 0ea37bd7fa..2ef9cd29de 100644 --- a/test/sync/futures/future/then_deferred_pass.cpp +++ b/test/sync/futures/future/then_deferred_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #include #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION diff --git a/test/sync/futures/future/then_executor_pass.cpp b/test/sync/futures/future/then_executor_pass.cpp index fcb062a0e8..11aae4d891 100644 --- a/test/sync/futures/future/then_executor_pass.cpp +++ b/test/sync/futures/future/then_executor_pass.cpp @@ -18,7 +18,7 @@ #include #include #include -#include +#include #include #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION diff --git a/test/sync/futures/future/then_pass.cpp b/test/sync/futures/future/then_pass.cpp index 12270679ba..1ce7ae57c2 100644 --- a/test/sync/futures/future/then_pass.cpp +++ b/test/sync/futures/future/then_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION diff --git a/test/sync/futures/future/wait_for_pass.cpp b/test/sync/futures/future/wait_for_pass.cpp index a130a2763e..10a99b52b4 100644 --- a/test/sync/futures/future/wait_for_pass.cpp +++ b/test/sync/futures/future/wait_for_pass.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO @@ -56,13 +56,13 @@ void func1(boost::promise p) p.set_value(3); } -int j = 0; +int g_j = 0; void func3(boost::promise p) { boost::this_thread::sleep_for(ms(500)); - j = 5; - p.set_value(j); + g_j = 5; + p.set_value(g_j); } void func5(boost::promise p) @@ -86,13 +86,13 @@ int main() boost::thread(func1, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_for(ms(100)) , boost::future_status::timeout); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func1(boost::move(p)); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_for(ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -109,13 +109,13 @@ int main() boost::thread(func3, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_for(ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func3(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_for(ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_for(ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -132,13 +132,13 @@ int main() boost::thread(func5, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_for(ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func5(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_for(ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_for(ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); diff --git a/test/sync/futures/future/wait_pass.cpp b/test/sync/futures/future/wait_pass.cpp index 1377f4b93c..fcdf12cf93 100644 --- a/test/sync/futures/future/wait_pass.cpp +++ b/test/sync/futures/future/wait_pass.cpp @@ -28,7 +28,7 @@ #include #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO @@ -54,13 +54,13 @@ void func1(boost::promise p) p.set_value(3); } -int j = 0; +int g_j = 0; void func3(boost::promise p) { boost::this_thread::sleep_for(ms(500)); - j = 5; - p.set_value(j); + g_j = 5; + p.set_value(g_j); } void func5(boost::promise p) diff --git a/test/sync/futures/future/wait_until_pass.cpp b/test/sync/futures/future/wait_until_pass.cpp index 9d93d9d388..0a34fec70a 100644 --- a/test/sync/futures/future/wait_until_pass.cpp +++ b/test/sync/futures/future/wait_until_pass.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO @@ -57,13 +57,13 @@ void func1(boost::promise p) p.set_value(3); } -int j = 0; +int g_j = 0; void func3(boost::promise p) { boost::this_thread::sleep_for(ms(500)); - j = 5; - p.set_value(j); + g_j = 5; + p.set_value(g_j); } void func5(boost::promise p) @@ -87,13 +87,13 @@ int main() boost::thread(func1, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(100)) , boost::future_status::timeout); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func1(boost::move(p)); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -110,13 +110,13 @@ int main() boost::thread(func3, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func3(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -133,13 +133,13 @@ int main() boost::thread(func5, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func5(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); diff --git a/test/sync/futures/make_ready_future_pass.cpp b/test/sync/futures/make_ready_future_pass.cpp index dfce3cde74..c006e65489 100644 --- a/test/sync/futures/make_ready_future_pass.cpp +++ b/test/sync/futures/make_ready_future_pass.cpp @@ -29,7 +29,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include struct A diff --git a/test/sync/futures/packaged_task/alloc_ctor_pass.cpp b/test/sync/futures/packaged_task/alloc_ctor_pass.cpp index e83c064463..4164780c24 100644 --- a/test/sync/futures/packaged_task/alloc_ctor_pass.cpp +++ b/test/sync/futures/packaged_task/alloc_ctor_pass.cpp @@ -29,7 +29,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS diff --git a/test/sync/futures/packaged_task/copy_assign_fail.cpp b/test/sync/futures/packaged_task/copy_assign_fail.cpp index 7f068eced1..ad6088ccf0 100644 --- a/test/sync/futures/packaged_task/copy_assign_fail.cpp +++ b/test/sync/futures/packaged_task/copy_assign_fail.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/copy_ctor_fail.cpp b/test/sync/futures/packaged_task/copy_ctor_fail.cpp index 22a174961a..a69ee4b353 100644 --- a/test/sync/futures/packaged_task/copy_ctor_fail.cpp +++ b/test/sync/futures/packaged_task/copy_ctor_fail.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/default_ctor_pass.cpp b/test/sync/futures/packaged_task/default_ctor_pass.cpp index 7ab9f1e7c3..9012982e3d 100644 --- a/test/sync/futures/packaged_task/default_ctor_pass.cpp +++ b/test/sync/futures/packaged_task/default_ctor_pass.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include #include int main() diff --git a/test/sync/futures/packaged_task/dtor_pass.cpp b/test/sync/futures/packaged_task/dtor_pass.cpp index 89620ad058..ca00c22782 100644 --- a/test/sync/futures/packaged_task/dtor_pass.cpp +++ b/test/sync/futures/packaged_task/dtor_pass.cpp @@ -24,7 +24,7 @@ #include #include -#include +#include #if BOOST_THREAD_VERSION == 4 #define BOOST_THREAD_DETAIL_SIGNATURE double() diff --git a/test/sync/futures/packaged_task/func_ctor_pass.cpp b/test/sync/futures/packaged_task/func_ctor_pass.cpp index a4bd3105f6..bcd612c063 100644 --- a/test/sync/futures/packaged_task/func_ctor_pass.cpp +++ b/test/sync/futures/packaged_task/func_ctor_pass.cpp @@ -22,7 +22,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #if BOOST_THREAD_VERSION == 4 #define BOOST_THREAD_DETAIL_SIGNATURE double() diff --git a/test/sync/futures/packaged_task/get_future_pass.cpp b/test/sync/futures/packaged_task/get_future_pass.cpp index 7b29857945..c1bcae94b6 100644 --- a/test/sync/futures/packaged_task/get_future_pass.cpp +++ b/test/sync/futures/packaged_task/get_future_pass.cpp @@ -27,7 +27,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp b/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp index 08db7bbf24..a82005cd2b 100644 --- a/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp +++ b/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO && \ defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && \ diff --git a/test/sync/futures/packaged_task/member_swap_pass.cpp b/test/sync/futures/packaged_task/member_swap_pass.cpp index fe3c062f85..618c832f17 100644 --- a/test/sync/futures/packaged_task/member_swap_pass.cpp +++ b/test/sync/futures/packaged_task/member_swap_pass.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/move_assign_pass.cpp b/test/sync/futures/packaged_task/move_assign_pass.cpp index fe696c8fb4..9dc8021d32 100644 --- a/test/sync/futures/packaged_task/move_assign_pass.cpp +++ b/test/sync/futures/packaged_task/move_assign_pass.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/move_ctor_pass.cpp b/test/sync/futures/packaged_task/move_ctor_pass.cpp index a5085b3110..2c7e9c6605 100644 --- a/test/sync/futures/packaged_task/move_ctor_pass.cpp +++ b/test/sync/futures/packaged_task/move_ctor_pass.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/non_member_swap_pass.cpp b/test/sync/futures/packaged_task/non_member_swap_pass.cpp index fb579094da..5f4511b694 100644 --- a/test/sync/futures/packaged_task/non_member_swap_pass.cpp +++ b/test/sync/futures/packaged_task/non_member_swap_pass.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/operator_pass.cpp b/test/sync/futures/packaged_task/operator_pass.cpp index db932f72b9..4b067d3666 100644 --- a/test/sync/futures/packaged_task/operator_pass.cpp +++ b/test/sync/futures/packaged_task/operator_pass.cpp @@ -22,7 +22,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/futures/packaged_task/reset_pass.cpp b/test/sync/futures/packaged_task/reset_pass.cpp index 711e7a57fb..4e8cb40450 100644 --- a/test/sync/futures/packaged_task/reset_pass.cpp +++ b/test/sync/futures/packaged_task/reset_pass.cpp @@ -26,7 +26,7 @@ #endif #include -#include +#include class A { diff --git a/test/sync/futures/packaged_task/types_pass.cpp b/test/sync/futures/packaged_task/types_pass.cpp index a52fb04398..6d677acece 100644 --- a/test/sync/futures/packaged_task/types_pass.cpp +++ b/test/sync/futures/packaged_task/types_pass.cpp @@ -23,7 +23,8 @@ #include #include -#include +#include +#include struct A {}; diff --git a/test/sync/futures/packaged_task/use_allocator_pass.cpp b/test/sync/futures/packaged_task/use_allocator_pass.cpp index ef75b7caaf..3f65eef2a9 100644 --- a/test/sync/futures/packaged_task/use_allocator_pass.cpp +++ b/test/sync/futures/packaged_task/use_allocator_pass.cpp @@ -29,7 +29,7 @@ #endif #include -#include +#include #include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS diff --git a/test/sync/futures/promise/alloc_ctor_pass.cpp b/test/sync/futures/promise/alloc_ctor_pass.cpp index 0d0c3c0b9e..7c018b34c9 100644 --- a/test/sync/futures/promise/alloc_ctor_pass.cpp +++ b/test/sync/futures/promise/alloc_ctor_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #include "../test_allocator.hpp" diff --git a/test/sync/futures/promise/copy_assign_fail.cpp b/test/sync/futures/promise/copy_assign_fail.cpp index 07895578f3..59c505c039 100644 --- a/test/sync/futures/promise/copy_assign_fail.cpp +++ b/test/sync/futures/promise/copy_assign_fail.cpp @@ -18,7 +18,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/promise/copy_ctor_fail.cpp b/test/sync/futures/promise/copy_ctor_fail.cpp index cfd67a6d70..6a1a380289 100644 --- a/test/sync/futures/promise/copy_ctor_fail.cpp +++ b/test/sync/futures/promise/copy_ctor_fail.cpp @@ -18,7 +18,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/promise/default_pass.cpp b/test/sync/futures/promise/default_pass.cpp index 00198a1687..e9ab069cc8 100644 --- a/test/sync/futures/promise/default_pass.cpp +++ b/test/sync/futures/promise/default_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/promise/dtor_pass.cpp b/test/sync/futures/promise/dtor_pass.cpp index e449c03787..09877e4e39 100644 --- a/test/sync/futures/promise/dtor_pass.cpp +++ b/test/sync/futures/promise/dtor_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/promise/emplace_pass.cpp b/test/sync/futures/promise/emplace_pass.cpp index 6a1a352925..af2ffc7059 100644 --- a/test/sync/futures/promise/emplace_pass.cpp +++ b/test/sync/futures/promise/emplace_pass.cpp @@ -22,7 +22,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include struct A diff --git a/test/sync/futures/promise/get_future_pass.cpp b/test/sync/futures/promise/get_future_pass.cpp index 13a63b13dc..4b9ae8fc6a 100644 --- a/test/sync/futures/promise/get_future_pass.cpp +++ b/test/sync/futures/promise/get_future_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/promise/move_assign_pass.cpp b/test/sync/futures/promise/move_assign_pass.cpp index 0190527c05..d8bdb690b8 100644 --- a/test/sync/futures/promise/move_assign_pass.cpp +++ b/test/sync/futures/promise/move_assign_pass.cpp @@ -21,14 +21,11 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #include "../test_allocator.hpp" #endif -boost::mutex m0; -boost::mutex m1; - int main() { #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS diff --git a/test/sync/futures/promise/move_ctor_pass.cpp b/test/sync/futures/promise/move_ctor_pass.cpp index a72eb18295..e9be60645a 100644 --- a/test/sync/futures/promise/move_ctor_pass.cpp +++ b/test/sync/futures/promise/move_ctor_pass.cpp @@ -21,13 +21,11 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #include "../test_allocator.hpp" #endif -boost::mutex m; - int main() { #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS @@ -148,4 +146,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp b/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp index 27754d65ce..ac79bf27eb 100644 --- a/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp +++ b/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #include template diff --git a/test/sync/futures/promise/set_exception_pass.cpp b/test/sync/futures/promise/set_exception_pass.cpp index 10a400eb80..eda2445b92 100644 --- a/test/sync/futures/promise/set_exception_pass.cpp +++ b/test/sync/futures/promise/set_exception_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include template diff --git a/test/sync/futures/promise/set_lvalue_at_thread_exit_pass.cpp b/test/sync/futures/promise/set_lvalue_at_thread_exit_pass.cpp index a143dc636f..58f12bc789 100644 --- a/test/sync/futures/promise/set_lvalue_at_thread_exit_pass.cpp +++ b/test/sync/futures/promise/set_lvalue_at_thread_exit_pass.cpp @@ -21,25 +21,25 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #include -int i = 0; +int g_i = 0; //void func(boost::promise p) -boost::promise p; +boost::promise g_p; void func() { - p.set_value_at_thread_exit(i); - i = 4; + g_p.set_value_at_thread_exit(g_i); + g_i = 4; } int main() { { - //boost::promise p; - boost::future f = p.get_future(); - //boost::thread(func, boost::move(p)).detach(); + //boost::promise g_p; + boost::future f = g_p.get_future(); + //boost::thread(func, boost::move(g_p)).detach(); boost::thread(func).detach(); int r = f.get(); BOOST_TEST(r == 4); diff --git a/test/sync/futures/promise/set_lvalue_pass.cpp b/test/sync/futures/promise/set_lvalue_pass.cpp index 6acfb62d14..656020e58f 100644 --- a/test/sync/futures/promise/set_lvalue_pass.cpp +++ b/test/sync/futures/promise/set_lvalue_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include int main() diff --git a/test/sync/futures/promise/set_rvalue_at_thread_exit_pass.cpp b/test/sync/futures/promise/set_rvalue_at_thread_exit_pass.cpp index 0b23b48347..b72245d62a 100644 --- a/test/sync/futures/promise/set_rvalue_at_thread_exit_pass.cpp +++ b/test/sync/futures/promise/set_rvalue_at_thread_exit_pass.cpp @@ -21,31 +21,31 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include #include -boost::promise > p; -boost::promise > p2; +boost::promise > g_p; +boost::promise > g_p2; void func() { boost::csbl::unique_ptr uptr(new int(5)); - p.set_value_at_thread_exit(boost::move(uptr)); + g_p.set_value_at_thread_exit(boost::move(uptr)); } void func2() { - p2.set_value_at_thread_exit(boost::csbl::make_unique(5)); + g_p2.set_value_at_thread_exit(boost::csbl::make_unique(5)); } int main() { { - boost::future > f = p.get_future(); + boost::future > f = g_p.get_future(); boost::thread(func).detach(); BOOST_TEST(*f.get() == 5); } { - boost::future > f = p2.get_future(); + boost::future > f = g_p2.get_future(); boost::thread(func2).detach(); BOOST_TEST(*f.get() == 5); } diff --git a/test/sync/futures/promise/set_rvalue_pass.cpp b/test/sync/futures/promise/set_rvalue_pass.cpp index 63260d7268..234e482caf 100644 --- a/test/sync/futures/promise/set_rvalue_pass.cpp +++ b/test/sync/futures/promise/set_rvalue_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include struct A diff --git a/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp b/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp index 4972cb7d8d..41db3033a7 100644 --- a/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp +++ b/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp @@ -21,28 +21,28 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) -void func(boost::promise p) +void func(boost::promise prom) #else -boost::promise p; +boost::promise prom; void func() #endif { const int i = 5; - p.set_value_at_thread_exit(i); + prom.set_value_at_thread_exit(i); } int main() { { #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) - boost::promise p; - boost::future f = p.get_future(); - boost::thread(func, boost::move(p)).detach(); + boost::promise prom; + boost::future f = prom.get_future(); + boost::thread(func, boost::move(prom)).detach(); #else - boost::future f = p.get_future(); + boost::future f = prom.get_future(); boost::thread(func).detach(); #endif try diff --git a/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp b/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp index c79f2a23e3..8bc419d512 100644 --- a/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp +++ b/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp @@ -21,37 +21,37 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include -int i = 0; +int g_i = 0; -boost::promise p; +boost::promise g_p; void func() { - p.set_value_at_thread_exit(); - i = 1; + g_p.set_value_at_thread_exit(); + g_i = 1; } //void func2_mv(BOOST_THREAD_RV_REF(boost::promise) p2) void func2_mv(boost::promise p2) { p2.set_value_at_thread_exit(); - i = 2; + g_i = 2; } void func2(boost::promise *p2) { p2->set_value_at_thread_exit(); - i = 2; + g_i = 2; } int main() { try { - boost::future f = p.get_future(); + boost::future f = g_p.get_future(); boost::thread(func).detach(); f.get(); - BOOST_TEST(i == 1); + BOOST_TEST(g_i == 1); } catch(std::exception& ) @@ -67,10 +67,10 @@ int main() { boost::promise p2; boost::future f = p2.get_future(); - p = boost::move(p2); + g_p = boost::move(p2); boost::thread(func).detach(); f.get(); - BOOST_TEST(i == 1); + BOOST_TEST(g_i == 1); } catch(std::exception& ex) @@ -94,7 +94,7 @@ int main() #endif f.wait(); f.get(); - BOOST_TEST(i == 2); + BOOST_TEST(g_i == 2); } catch(std::exception& ex) { diff --git a/test/sync/futures/promise/set_value_const_pass.cpp b/test/sync/futures/promise/set_value_const_pass.cpp index 84f2fb2739..66e6de4d20 100644 --- a/test/sync/futures/promise/set_value_const_pass.cpp +++ b/test/sync/futures/promise/set_value_const_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include #include diff --git a/test/sync/futures/promise/set_value_void_pass.cpp b/test/sync/futures/promise/set_value_void_pass.cpp index 7c11d5b666..664e055bf2 100644 --- a/test/sync/futures/promise/set_value_void_pass.cpp +++ b/test/sync/futures/promise/set_value_void_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include struct A diff --git a/test/sync/futures/promise/use_allocator_pass.cpp b/test/sync/futures/promise/use_allocator_pass.cpp index 3b1e96c7eb..bd9f8d135b 100644 --- a/test/sync/futures/promise/use_allocator_pass.cpp +++ b/test/sync/futures/promise/use_allocator_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include #include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS diff --git a/test/sync/futures/shared_future/copy_assign_pass.cpp b/test/sync/futures/shared_future/copy_assign_pass.cpp index 1b23b2d160..24a56a63e0 100644 --- a/test/sync/futures/shared_future/copy_assign_pass.cpp +++ b/test/sync/futures/shared_future/copy_assign_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/shared_future/copy_ctor_pass.cpp b/test/sync/futures/shared_future/copy_ctor_pass.cpp index fd29c0fe31..4990d3bba7 100644 --- a/test/sync/futures/shared_future/copy_ctor_pass.cpp +++ b/test/sync/futures/shared_future/copy_ctor_pass.cpp @@ -20,7 +20,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/shared_future/default_pass.cpp b/test/sync/futures/shared_future/default_pass.cpp index 59ecea3a31..e1b74d961e 100644 --- a/test/sync/futures/shared_future/default_pass.cpp +++ b/test/sync/futures/shared_future/default_pass.cpp @@ -21,7 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include int main() { diff --git a/test/sync/futures/shared_future/dtor_pass.cpp b/test/sync/futures/shared_future/dtor_pass.cpp index 01fb591c04..159368e093 100644 --- a/test/sync/futures/shared_future/dtor_pass.cpp +++ b/test/sync/futures/shared_future/dtor_pass.cpp @@ -22,7 +22,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #include "../test_allocator.hpp" #endif diff --git a/test/sync/futures/shared_future/get_pass.cpp b/test/sync/futures/shared_future/get_pass.cpp index 067a70b2a8..1f002abbd9 100644 --- a/test/sync/futures/shared_future/get_pass.cpp +++ b/test/sync/futures/shared_future/get_pass.cpp @@ -24,7 +24,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/futures/shared_future/move_assign_pass.cpp b/test/sync/futures/shared_future/move_assign_pass.cpp index 40ff4992c3..b71296c154 100644 --- a/test/sync/futures/shared_future/move_assign_pass.cpp +++ b/test/sync/futures/shared_future/move_assign_pass.cpp @@ -21,10 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include - -boost::mutex m0; -boost::mutex m1; +#include int main() { diff --git a/test/sync/futures/shared_future/move_ctor_pass.cpp b/test/sync/futures/shared_future/move_ctor_pass.cpp index 533f5ec90c..c38eb2a4ff 100644 --- a/test/sync/futures/shared_future/move_ctor_pass.cpp +++ b/test/sync/futures/shared_future/move_ctor_pass.cpp @@ -21,9 +21,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include - -boost::mutex m; +#include int main() { @@ -75,4 +73,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/futures/shared_future/then_executor_pass.cpp b/test/sync/futures/shared_future/then_executor_pass.cpp index 73b42fc8ad..daffcd0e4e 100644 --- a/test/sync/futures/shared_future/then_executor_pass.cpp +++ b/test/sync/futures/shared_future/then_executor_pass.cpp @@ -19,7 +19,7 @@ #include #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION diff --git a/test/sync/futures/shared_future/then_pass.cpp b/test/sync/futures/shared_future/then_pass.cpp index e7cca062e1..ffa6bedaf4 100644 --- a/test/sync/futures/shared_future/then_pass.cpp +++ b/test/sync/futures/shared_future/then_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION diff --git a/test/sync/futures/shared_future/wait_for_pass.cpp b/test/sync/futures/shared_future/wait_for_pass.cpp index f231fbe863..7e535eb07d 100644 --- a/test/sync/futures/shared_future/wait_for_pass.cpp +++ b/test/sync/futures/shared_future/wait_for_pass.cpp @@ -28,7 +28,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO @@ -86,13 +86,13 @@ int main() boost::thread(func1, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_for(ms(100)) , boost::future_status::timeout); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func1(boost::move(p)); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_for(ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -109,13 +109,13 @@ int main() boost::thread(func3, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_for(ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func3(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_for(ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_for(ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -132,13 +132,13 @@ int main() boost::thread(func5, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_for(ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_for(ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func5(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_for(ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_for(ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); diff --git a/test/sync/futures/shared_future/wait_pass.cpp b/test/sync/futures/shared_future/wait_pass.cpp index c31cd8e6f0..e0e2991a22 100644 --- a/test/sync/futures/shared_future/wait_pass.cpp +++ b/test/sync/futures/shared_future/wait_pass.cpp @@ -28,7 +28,7 @@ #include #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/sync/futures/shared_future/wait_until_pass.cpp b/test/sync/futures/shared_future/wait_until_pass.cpp index d1ee4c8986..5a8bd5e6a9 100644 --- a/test/sync/futures/shared_future/wait_until_pass.cpp +++ b/test/sync/futures/shared_future/wait_until_pass.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO @@ -87,13 +87,13 @@ int main() boost::thread(func1, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(100)) , boost::future_status::timeout); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func1(boost::move(p)); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -110,13 +110,13 @@ int main() boost::thread(func3, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func3(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); @@ -133,13 +133,13 @@ int main() boost::thread(func5, boost::move(p)).detach(); #endif BOOST_TEST(f.valid()); - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(250)) , boost::future_status::timeout); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(100)) , boost::future_status::timeout); BOOST_TEST(f.valid()); #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) #else func5(boost::move(p)); #endif - BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(750)) , boost::future_status::ready); + BOOST_TEST_EQ(f.wait_until(Clock::now() + ms(2000)) , boost::future_status::ready); BOOST_TEST(f.valid()); Clock::time_point t0 = Clock::now(); f.wait(); diff --git a/test/sync/futures/when_all/iterators_pass.cpp b/test/sync/futures/when_all/iterators_pass.cpp index 2646074f09..5cc72b77c4 100644 --- a/test/sync/futures/when_all/iterators_pass.cpp +++ b/test/sync/futures/when_all/iterators_pass.cpp @@ -28,7 +28,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #include #ifdef BOOST_MSVC @@ -332,28 +332,28 @@ int main() } #endif #if ! defined BOOST_NO_CXX11_LAMBDAS - { // async futures copy-constructible then() - boost::future f1 = boost::async(boost::launch::async, &p1); - BOOST_TEST(f1.valid()); - boost::future f2 = boost::async(boost::launch::async, &p2); - BOOST_TEST(f2.valid()); - boost::csbl::vector > v; - v.push_back(boost::move(f1)); - v.push_back(boost::move(f2)); - BOOST_TEST(v[0].valid()); - BOOST_TEST(v[1].valid()); - boost::future > > all = boost::when_all(v.begin(), v.end()); - BOOST_TEST(! v[0].valid()); - BOOST_TEST(! v[1].valid()); - BOOST_TEST(all.valid()); - boost::future sum = all.then([](boost::future > > f) - { - boost::csbl::vector > v = f.get(); - return v[0].get() + v[1].get(); - }); - BOOST_TEST(sum.valid()); - BOOST_TEST(sum.get() == 444); - } + { // async futures copy-constructible then() + boost::future f1 = boost::async(boost::launch::async, &p1); + BOOST_TEST(f1.valid()); + boost::future f2 = boost::async(boost::launch::async, &p2); + BOOST_TEST(f2.valid()); + boost::csbl::vector > v; + v.push_back(boost::move(f1)); + v.push_back(boost::move(f2)); + BOOST_TEST(v[0].valid()); + BOOST_TEST(v[1].valid()); + boost::future > > all = boost::when_all(v.begin(), v.end()); + BOOST_TEST(! v[0].valid()); + BOOST_TEST(! v[1].valid()); + BOOST_TEST(all.valid()); + boost::future sum = all.then([](boost::future > > f) + { + boost::csbl::vector > v = f.get(); + return v[0].get() + v[1].get(); + }); + BOOST_TEST(sum.valid()); + BOOST_TEST(sum.get() == 444); + } #endif #endif diff --git a/test/sync/futures/when_all/none_pass.cpp b/test/sync/futures/when_all/none_pass.cpp index 613e2368da..ca4d2c8ddf 100644 --- a/test/sync/futures/when_all/none_pass.cpp +++ b/test/sync/futures/when_all/none_pass.cpp @@ -26,7 +26,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include int main() { diff --git a/test/sync/futures/when_all/one_pass.cpp b/test/sync/futures/when_all/one_pass.cpp index 026abcf53a..68397e8cae 100644 --- a/test/sync/futures/when_all/one_pass.cpp +++ b/test/sync/futures/when_all/one_pass.cpp @@ -27,7 +27,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #include #ifdef BOOST_MSVC diff --git a/test/sync/futures/when_all/variadic_pass.cpp b/test/sync/futures/when_all/variadic_pass.cpp index f3b93b8be5..e4b2e2d8b9 100644 --- a/test/sync/futures/when_all/variadic_pass.cpp +++ b/test/sync/futures/when_all/variadic_pass.cpp @@ -27,7 +27,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #include #ifdef BOOST_MSVC @@ -36,7 +36,6 @@ int p1() { - boost::this_thread::sleep_for(boost::chrono::milliseconds(100)); return 123; } @@ -44,9 +43,9 @@ int thr() { throw std::logic_error("123"); } + int p2() { - boost::this_thread::sleep_for(boost::chrono::milliseconds(200)); return 321; } @@ -275,23 +274,23 @@ int main() } #endif #if ! defined BOOST_NO_CXX11_LAMBDAS - { // async futures copy-constructible then() - boost::future f1 = boost::async(boost::launch::async, &p1); - BOOST_TEST(f1.valid()); - boost::future f2 = boost::async(boost::launch::async, &p2); - BOOST_TEST(f2.valid()); - boost::future,boost::future > > all = boost::when_all(boost::move(f1), boost::move(f2)); - BOOST_TEST(! f1.valid()); - BOOST_TEST(! f2.valid()); - BOOST_TEST(all.valid()); - boost::future sum = all.then([](boost::future, boost::future > > f) - { - boost::csbl::tuple,boost::future > v = f.get(); - return boost::csbl::get<0>(v).get()+boost::csbl::get<1>(v).get(); - }); - BOOST_TEST(sum.valid()); - BOOST_TEST(sum.get() == 444); - } + { // async futures copy-constructible then() + boost::future f1 = boost::async(boost::launch::async, &p1); + BOOST_TEST(f1.valid()); + boost::future f2 = boost::async(boost::launch::async, &p2); + BOOST_TEST(f2.valid()); + boost::future,boost::future > > all = boost::when_all(boost::move(f1), boost::move(f2)); + BOOST_TEST(! f1.valid()); + BOOST_TEST(! f2.valid()); + BOOST_TEST(all.valid()); + boost::future sum = all.then([](boost::future, boost::future > > f) + { + boost::csbl::tuple,boost::future > v = f.get(); + return boost::csbl::get<0>(v).get()+boost::csbl::get<1>(v).get(); + }); + BOOST_TEST(sum.valid()); + BOOST_TEST(sum.get() == 444); + } #endif #endif diff --git a/test/sync/futures/when_any/iterators_pass.cpp b/test/sync/futures/when_any/iterators_pass.cpp index 03336d0226..55a86fd2a6 100644 --- a/test/sync/futures/when_any/iterators_pass.cpp +++ b/test/sync/futures/when_any/iterators_pass.cpp @@ -28,7 +28,8 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include +#include #include #ifdef BOOST_MSVC @@ -44,9 +45,16 @@ int thr() { throw std::logic_error("123"); } + int p2() { - boost::this_thread::sleep_for(boost::chrono::milliseconds(200)); + return 321; +} + +int p3(boost::barrier* bar = nullptr) +{ + if (bar) + bar->count_down_and_wait(); return 321; } @@ -217,9 +225,10 @@ int main() BOOST_TEST(res[1].get() == 321); } { // async future copy-constructible + boost::barrier bar(2u); boost::future f1 = boost::async(boost::launch::async, &p1); BOOST_TEST(f1.valid()); - boost::future f2 = boost::async(boost::launch::async, &p2); + boost::future f2 = boost::async(boost::launch::async, &p3, &bar); BOOST_TEST(f2.valid()); boost::csbl::vector > v; v.push_back(boost::move(f1)); @@ -236,12 +245,14 @@ int main() BOOST_TEST(res[0].get() == 123); BOOST_TEST(res[1].valid()); BOOST_TEST(! res[1].is_ready()); + bar.count_down_and_wait(); BOOST_TEST(res[1].get() == 321); } { // async shared_future copy-constructible + boost::barrier bar(2u); boost::shared_future f1 = boost::async(boost::launch::async, &p1).share(); BOOST_TEST(f1.valid()); - boost::shared_future f2 = boost::async(boost::launch::async, &p2).share(); + boost::shared_future f2 = boost::async(boost::launch::async, &p3, &bar).share(); BOOST_TEST(f2.valid()); boost::csbl::vector > v; v.push_back(f1); @@ -260,6 +271,7 @@ int main() BOOST_TEST(res[0].get() == 123); BOOST_TEST(res[1].valid()); BOOST_TEST(! res[1].is_ready()); + bar.count_down_and_wait(); BOOST_TEST(res[1].get() == 321); } { // async future copy-constructible @@ -333,31 +345,30 @@ int main() } #endif #if ! defined BOOST_NO_CXX11_LAMBDAS - { // async futures copy-constructible then() - boost::future f1 = boost::async(boost::launch::async, &p1); - BOOST_TEST(f1.valid()); - boost::future f2 = boost::async(boost::launch::async, &p2); - BOOST_TEST(f2.valid()); - boost::csbl::vector > v; - v.push_back(boost::move(f1)); - v.push_back(boost::move(f2)); - BOOST_TEST(v[0].valid()); - BOOST_TEST(v[1].valid()); - boost::future > > all = boost::when_any(v.begin(), v.end()); - BOOST_TEST(! v[0].valid()); - BOOST_TEST(! v[1].valid()); - BOOST_TEST(all.valid()); - boost::future sum = all.then([](boost::future > > f) - { - boost::csbl::vector > v = f.get(); - return v[0].get() + v[1].get(); - }); - BOOST_TEST(sum.valid()); - BOOST_TEST(sum.get() == 444); - } + { // async futures copy-constructible then() + boost::future f1 = boost::async(boost::launch::async, &p1); + BOOST_TEST(f1.valid()); + boost::future f2 = boost::async(boost::launch::async, &p2); + BOOST_TEST(f2.valid()); + boost::csbl::vector > v; + v.push_back(boost::move(f1)); + v.push_back(boost::move(f2)); + BOOST_TEST(v[0].valid()); + BOOST_TEST(v[1].valid()); + boost::future > > all = boost::when_any(v.begin(), v.end()); + BOOST_TEST(! v[0].valid()); + BOOST_TEST(! v[1].valid()); + BOOST_TEST(all.valid()); + boost::future sum = all.then([](boost::future > > f) + { + boost::csbl::vector > v = f.get(); + return v[0].get() + v[1].get(); + }); + BOOST_TEST(sum.valid()); + BOOST_TEST(sum.get() == 444); + } #endif #endif return boost::report_errors(); } - diff --git a/test/sync/futures/when_any/none_pass.cpp b/test/sync/futures/when_any/none_pass.cpp index 2edd0bc6d2..672988e3c1 100644 --- a/test/sync/futures/when_any/none_pass.cpp +++ b/test/sync/futures/when_any/none_pass.cpp @@ -26,7 +26,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include int main() { diff --git a/test/sync/futures/when_any/one_pass.cpp b/test/sync/futures/when_any/one_pass.cpp index 61882ef6d8..ba2ee738d7 100644 --- a/test/sync/futures/when_any/one_pass.cpp +++ b/test/sync/futures/when_any/one_pass.cpp @@ -26,7 +26,7 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include #ifdef BOOST_MSVC #pragma warning(disable: 4127) // conditional expression is constant diff --git a/test/sync/futures/when_any/variadic_pass.cpp b/test/sync/futures/when_any/variadic_pass.cpp index 09b3951fcb..2d831427e1 100644 --- a/test/sync/futures/when_any/variadic_pass.cpp +++ b/test/sync/futures/when_any/variadic_pass.cpp @@ -26,7 +26,8 @@ #define BOOST_THREAD_VERSION 4 #include -#include +#include +#include #include #ifdef BOOST_MSVC @@ -42,9 +43,16 @@ int thr() { throw std::logic_error("123"); } + int p2() { - boost::this_thread::sleep_for(boost::chrono::milliseconds(200)); + return 321; +} + +int p3(boost::barrier* bar = nullptr) +{ + if (bar) + bar->count_down_and_wait(); return 321; } @@ -180,9 +188,10 @@ int main() BOOST_TEST(boost::csbl::get<1>(res).get() == 321); } { // async future copy-constructible + boost::barrier bar(2u); boost::future f1 = boost::async(boost::launch::async, &p1); BOOST_TEST(f1.valid()); - boost::future f2 = boost::async(boost::launch::async, &p2); + boost::future f2 = boost::async(boost::launch::async, &p3, &bar); BOOST_TEST(f2.valid()); boost::future,boost::future > > all = boost::when_any(boost::move(f1), boost::move(f2)); BOOST_TEST(! f1.valid()); @@ -192,12 +201,14 @@ int main() BOOST_TEST(boost::csbl::get<0>(res).valid()); BOOST_TEST(boost::csbl::get<0>(res).is_ready() || boost::csbl::get<1>(res).is_ready()); BOOST_TEST(boost::csbl::get<0>(res).get() == 123); + bar.count_down_and_wait(); BOOST_TEST(boost::csbl::get<1>(res).get() == 321); } { // async shared_future copy-constructible + boost::barrier bar(2u); boost::shared_future f1 = boost::async(boost::launch::async, &p1).share(); BOOST_TEST(f1.valid()); - boost::shared_future f2 = boost::async(boost::launch::async, &p2).share(); + boost::shared_future f2 = boost::async(boost::launch::async, &p3, &bar).share(); BOOST_TEST(f2.valid()); boost::future,boost::shared_future > > all = boost::when_any(f1, f2); BOOST_TEST(f1.valid()); @@ -208,6 +219,7 @@ int main() BOOST_TEST(boost::csbl::get<1>(res).valid()); BOOST_TEST(boost::csbl::get<0>(res).is_ready() || boost::csbl::get<1>(res).is_ready()); BOOST_TEST(boost::csbl::get<0>(res).get() == 123); + bar.count_down_and_wait(); BOOST_TEST(boost::csbl::get<1>(res).get() == 321); } { // async future copy-constructible @@ -251,8 +263,9 @@ int main() } // fixme darwin-4.8.0_11 terminate called without an active exception { // deferred future copy-constructible + boost::barrier bar(2u); boost::future f1 = boost::async(boost::launch::deferred, &p1); - boost::future f2 = boost::async(boost::launch::async, &p2); + boost::future f2 = boost::async(boost::launch::async, &p3, &bar); boost::future,boost::future > > all = boost::when_any(boost::move(f1), boost::move(f2)); BOOST_TEST(! f1.valid()); BOOST_TEST(! f2.valid()); @@ -262,7 +275,8 @@ int main() BOOST_TEST(boost::csbl::get<0>(res).is_ready()); BOOST_TEST(boost::csbl::get<0>(res).get() == 123); BOOST_TEST(boost::csbl::get<1>(res).valid()); - //BOOST_TEST(! boost::csbl::get<1>(res).is_ready()); + BOOST_TEST(! boost::csbl::get<1>(res).is_ready()); + bar.count_down_and_wait(); BOOST_TEST(boost::csbl::get<1>(res).get() == 321); } // fixme darwin-4.8.0_11 terminate called without an active exception @@ -298,23 +312,23 @@ int main() } #endif #if ! defined BOOST_NO_CXX11_LAMBDAS - { // async futures copy-constructible then() - boost::future f1 = boost::async(boost::launch::async, &p1); - BOOST_TEST(f1.valid()); - boost::future f2 = boost::async(boost::launch::async, &p2); - BOOST_TEST(f2.valid()); - boost::future,boost::future > > all = boost::when_any(boost::move(f1), boost::move(f2)); - BOOST_TEST(! f1.valid()); - BOOST_TEST(! f2.valid()); - BOOST_TEST(all.valid()); - boost::future sum = all.then([](boost::future, boost::future > > f) - { - boost::csbl::tuple,boost::future > v = f.get(); - return boost::csbl::get<0>(v).get()+boost::csbl::get<1>(v).get(); - }); - BOOST_TEST(sum.valid()); - BOOST_TEST(sum.get() == 444); - } + { // async futures copy-constructible then() + boost::future f1 = boost::async(boost::launch::async, &p1); + BOOST_TEST(f1.valid()); + boost::future f2 = boost::async(boost::launch::async, &p2); + BOOST_TEST(f2.valid()); + boost::future,boost::future > > all = boost::when_any(boost::move(f1), boost::move(f2)); + BOOST_TEST(! f1.valid()); + BOOST_TEST(! f2.valid()); + BOOST_TEST(all.valid()); + boost::future sum = all.then([](boost::future, boost::future > > f) + { + boost::csbl::tuple,boost::future > v = f.get(); + return boost::csbl::get<0>(v).get()+boost::csbl::get<1>(v).get(); + }); + BOOST_TEST(sum.valid()); + BOOST_TEST(sum.get() == 444); + } #endif #endif diff --git a/test/sync/mutual_exclusion/deque_views/single_thread_pass.cpp b/test/sync/mutual_exclusion/deque_views/single_thread_pass.cpp index bd9ff152fc..fc801248e4 100644 --- a/test/sync/mutual_exclusion/deque_views/single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/deque_views/single_thread_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #include class non_copyable @@ -90,7 +90,7 @@ int main() // empty queue push lvalue/copyable succeeds boost::deque_adaptor > sq; boost::deque_back q(sq); - int i; + int i = 42; q.push(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -140,7 +140,7 @@ int main() // empty queue push lvalue succeeds boost::deque_adaptor > sq; boost::deque_back q(sq); - int i; + int i = 42; q.push(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); diff --git a/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp index b6039c5560..fe999b12ff 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -30,50 +30,50 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #ifdef BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - m.lock(); - boost::lock_guard lg(m, boost::adopt_lock); - t1 = Clock::now(); + g_mutex.lock(); + boost::lock_guard lg(g_mutex, boost::adopt_lock); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - m.lock(); - boost::lock_guard lg(m, boost::adopt_lock); - //t1 = Clock::now(); + g_mutex.lock(); + boost::lock_guard lg(g_mutex, boost::adopt_lock); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #ifdef BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp index a3957c7502..092d167cc6 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp @@ -20,18 +20,17 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; +boost::mutex g_mutex1; int main() { - boost::lock_guard lk0(m0); - boost::lock_guard lk1(m1); + boost::lock_guard lk0(g_mutex0); + boost::lock_guard lk1(g_mutex1); lk1 = lk0; - + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp index 5c1b3a1c20..8b725c19a3 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp @@ -21,15 +21,15 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; int main() { - boost::lock_guard lk0(m0); + boost::lock_guard lk0(g_mutex0); boost::lock_guard lk1 = lk0; + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp index 4fcc26a9b4..3a4953064c 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -30,49 +30,49 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #ifdef BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::lock_guard lg(m); - t1 = Clock::now(); + boost::lock_guard lg(g_mutex); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - boost::lock_guard lg(m); - //t1 = Clock::now(); + boost::lock_guard lg(g_mutex); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #ifdef BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp index 9aab78dddf..49bae60cd4 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp @@ -11,11 +11,11 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; void fail() { - boost::lock_guard lk(m, boost::adopt_lock); + boost::lock_guard lk(g_mutex, boost::adopt_lock); } diff --git a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp index a158677ad6..c083f56346 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp @@ -11,12 +11,12 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; void pass() { - m.lock(); - boost::lock_guard lk(m, boost::adopt_lock); + g_mutex.lock(); + boost::lock_guard lk(g_mutex, boost::adopt_lock); } diff --git a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp index eead4501cb..6aa3ce0cf0 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp @@ -11,12 +11,12 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; void fail() { - boost::lock_guard lk0(m); - boost::lock_guard lk1(m); + boost::lock_guard lk0(g_mutex); + boost::lock_guard lk1(g_mutex); } diff --git a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp index aee2e40e41..afd860a577 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp @@ -11,14 +11,14 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; void pass() { { - boost::lock_guard lk0(m); + boost::lock_guard lk0(g_mutex); } - boost::lock_guard lk1(m); + boost::lock_guard lk1(g_mutex); } diff --git a/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_adopt_lock_pass.cpp index cecdc84ce0..42c35550d4 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_adopt_lock_pass.cpp @@ -22,7 +22,7 @@ #include #include #include -#include +#include #include "../../../../timming.hpp" @@ -32,10 +32,10 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD @@ -44,22 +44,22 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #ifdef BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - m.lock(); - auto&& lg = boost::make_lock_guard(m, boost::adopt_lock); (void)lg; + g_mutex.lock(); + auto&& lg = boost::make_lock_guard(g_mutex, boost::adopt_lock); (void)lg; - t1 = Clock::now(); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - m.lock(); - auto&& lg = boost::make_lock_guard(m, boost::adopt_lock); (void)lg; - //t1 = Clock::now(); + g_mutex.lock(); + auto&& lg = boost::make_lock_guard(g_mutex, boost::adopt_lock); (void)lg; + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } @@ -68,19 +68,19 @@ void f() int main() { #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD - m.lock(); + g_mutex.lock(); boost::thread t(f); #ifdef BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_pass.cpp index 853fae7439..e56f416155 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_pass.cpp @@ -23,7 +23,7 @@ #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -32,11 +32,11 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO @@ -44,10 +44,10 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { - t0 = Clock::now(); + g_t0 = Clock::now(); { - const auto&& lg = boost::make_lock_guard(m); (void)lg; - t1 = Clock::now(); + const auto&& lg = boost::make_lock_guard(g_mutex); (void)lg; + g_t1 = Clock::now(); } } #endif @@ -57,16 +57,16 @@ int main() #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO { - m.lock(); + g_mutex.lock(); boost::thread t(f); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp index 7c2d39375d..4a351d3625 100644 --- a/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_assign_fail.cpp index c5d9a39b55..9cab6dddbb 100644 --- a/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_assign_fail.cpp @@ -12,20 +12,19 @@ #include #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; +boost::mutex g_mutex1; int main() { - boost::unique_lock lk0(m0); - boost::unique_lock lk1(m1); + boost::unique_lock lk0(g_mutex0); + boost::unique_lock lk1(g_mutex1); boost::nested_strict_lock > nlk0(lk0); boost::nested_strict_lock > nlk1(lk1); lk1 = lk0; - + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp index 1c0abf94a2..0b6d3d2620 100644 --- a/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp @@ -13,16 +13,15 @@ #include #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; int main() { - boost::nested_strict_lock > lk0(m0); + boost::nested_strict_lock > lk0(g_mutex0); boost::nested_strict_lock > lk1 = lk0; + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp b/test/sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp index 0182bdd95e..aa05c6dbe5 100644 --- a/test/sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp @@ -13,7 +13,7 @@ #include #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -22,32 +22,32 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #ifdef BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - boost::unique_lock lg(m); + g_t0 = Clock::now(); + boost::unique_lock lg(g_mutex); { boost::nested_strict_lock > nlg(lg); - t1 = Clock::now(); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; - boost::unique_lock lg(m); + //time_point g_t0 = Clock::now(); + //time_point g_t1; + boost::unique_lock lg(g_mutex); { boost::nested_strict_lock > nlg(lg); - //t1 = Clock::now(); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } @@ -55,19 +55,19 @@ void f() int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f); #ifdef BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp b/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp index 5a10728cb8..0810e6c8e1 100644 --- a/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp @@ -15,7 +15,7 @@ #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -24,11 +24,11 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO @@ -36,11 +36,11 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { - t0 = Clock::now(); - boost::unique_lock lg(m); + g_t0 = Clock::now(); + boost::unique_lock lg(g_mutex); { const auto&& nlg = boost::make_nested_strict_lock(lg); (void)nlg; - t1 = Clock::now(); + g_t1 = Clock::now(); } } #endif @@ -50,16 +50,16 @@ int main() #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO { - m.lock(); + g_mutex.lock(); boost::thread t(f); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/nested_strict_lock/owns_lock_pass.cpp b/test/sync/mutual_exclusion/locks/nested_strict_lock/owns_lock_pass.cpp index be06b6a06a..c75f836c5b 100644 --- a/test/sync/mutual_exclusion/locks/nested_strict_lock/owns_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/nested_strict_lock/owns_lock_pass.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/nested_strict_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/nested_strict_lock/types_pass.cpp index 5a7c690e41..60b99513c7 100644 --- a/test/sync/mutual_exclusion/locks/nested_strict_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/nested_strict_lock/types_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/reverse_lock/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/reverse_lock/copy_assign_fail.cpp index 408e0f2672..42bd7cb98d 100644 --- a/test/sync/mutual_exclusion/locks/reverse_lock/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/reverse_lock/copy_assign_fail.cpp @@ -25,8 +25,8 @@ int main() boost::reverse_lock > lg0(lk0); boost::reverse_lock > lg1(lk1); lg1 = lg0; + (void)lg1; } - } #include "../../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/locks/reverse_lock/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/reverse_lock/copy_ctor_fail.cpp index c936c11b86..64ae7d70c5 100644 --- a/test/sync/mutual_exclusion/locks/reverse_lock/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/reverse_lock/copy_ctor_fail.cpp @@ -15,9 +15,6 @@ #include #include -boost::mutex m0; -boost::mutex m1; - int main() { boost::mutex m0; @@ -25,8 +22,8 @@ int main() { boost::reverse_lock > lg0(lk0); boost::reverse_lock > lg1(lg0); + (void)lg1; } } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/reverse_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/reverse_lock/types_pass.cpp index 13a17fd3aa..f3bb77d20a 100644 --- a/test/sync/mutual_exclusion/locks/reverse_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/reverse_lock/types_pass.cpp @@ -22,7 +22,7 @@ #include #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/reverse_lock/unique_lock_ctor_pass.cpp b/test/sync/mutual_exclusion/locks/reverse_lock/unique_lock_ctor_pass.cpp index 57a1f1e01b..6578336d16 100644 --- a/test/sync/mutual_exclusion/locks/reverse_lock/unique_lock_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/locks/reverse_lock/unique_lock_ctor_pass.cpp @@ -13,7 +13,7 @@ #include #include #include -#include +#include int main() diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp index f9089e7a81..1a970565d7 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include int main() diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp index 2bc99f34b7..ff616fdd86 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp @@ -20,17 +20,17 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { - boost::shared_lock lk0(m0); - boost::shared_lock lk1(m1); + boost::shared_lock lk0(g_mutex0); + boost::shared_lock lk1(g_mutex1); lk1 = lk0; - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp index 43fddebe87..ce78ba1fc9 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp @@ -21,20 +21,19 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { - boost::shared_lock lk0(m0); + boost::shared_lock lk0(g_mutex0); boost::shared_lock lk1 = lk0; - BOOST_TEST(lk1.mutex() == &m1); + BOOST_TEST(lk1.mutex() == &g_mutex1); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } #include "../../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp index 9ccae93b75..055d3746a8 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp index 84388aca4c..ed707f8982 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp index 45037c2241..5ae77d0dc7 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp @@ -22,63 +22,63 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - boost::shared_lock lk(m, ms(750)); + g_t0 = Clock::now(); + boost::shared_lock lk(g_mutex, ms(750)); BOOST_TEST(lk.owns_lock() == true); - t1 = Clock::now(); + g_t1 = Clock::now(); } void f2() { - t0 = Clock::now(); - boost::shared_lock lk(m, ms(250)); + g_t0 = Clock::now(); + boost::shared_lock lk(g_mutex, ms(250)); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp index ef54e229f9..6a99e0e747 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp @@ -21,62 +21,58 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { { - boost::shared_lock lk0(m0); - boost::shared_lock lk1(m1); + boost::shared_lock lk0(g_mutex0); + boost::shared_lock lk1(g_mutex1); lk1 = boost::move(lk0); - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk1; - lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(m0)); - BOOST_TEST(lk1.mutex() == &m0); + lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(g_mutex0)); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); } { - boost::unique_lock lk0(m0); - boost::shared_lock lk1(m1); + boost::unique_lock lk0(g_mutex0); + boost::shared_lock lk1(g_mutex1); lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(boost::move(lk0))); - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk1; - lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(boost::unique_lock(m0))); - BOOST_TEST(lk1.mutex() == &m0); + lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(boost::unique_lock(g_mutex0))); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); } { - boost::upgrade_lock lk0(m0); - boost::shared_lock lk1(m1); + boost::upgrade_lock lk0(g_mutex0); + boost::shared_lock lk1(g_mutex1); lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(boost::move(lk0))); - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk1; - lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(boost::upgrade_lock(m0))); - BOOST_TEST(lk1.mutex() == &m0); + lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(boost::upgrade_lock(g_mutex0))); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); } - return boost::report_errors(); + return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp index 307c761425..a825e0a6c5 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp @@ -21,27 +21,25 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(m)))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::shared_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::shared_lock(g_mutex)))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } - return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_unique_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_unique_lock_pass.cpp index 38f6e7d7db..e98112c784 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_unique_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_unique_lock_pass.cpp @@ -21,45 +21,42 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { - { - boost::unique_lock lk0(m); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::unique_lock lk0(g_mutex); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk( (boost::unique_lock(m))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::shared_lock lk( (boost::unique_lock(g_mutex))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } { - boost::unique_lock lk0(m, boost::defer_lock); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::unique_lock lk0(g_mutex, boost::defer_lock); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::unique_lock lk0(m, boost::defer_lock); - lk0.release(); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == 0); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::unique_lock lk0(g_mutex, boost::defer_lock); + lk0.release(); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == 0); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } - return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_upgrade_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_upgrade_lock_pass.cpp index 36ecb6a5ae..da5f9dc903 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_upgrade_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_upgrade_lock_pass.cpp @@ -21,44 +21,42 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { - { - boost::upgrade_lock lk0(m); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk( (boost::upgrade_lock(m))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::shared_lock lk( (boost::upgrade_lock(g_mutex))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } { - boost::upgrade_lock lk0(m, boost::defer_lock); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk0(m, boost::defer_lock); - lk0.release(); - boost::shared_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == 0); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); + lk0.release(); + boost::shared_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == 0); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp index f50aa6199a..5ba87ce831 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp @@ -21,10 +21,10 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -42,26 +42,26 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::shared_lock ul(m); - t1 = Clock::now(); + boost::shared_lock ul(g_mutex); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - boost::shared_lock ul(m); - //t1 = Clock::now(); + boost::shared_lock ul(g_mutex); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -69,12 +69,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp index 41d9cd8f98..5fb1eeb443 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp @@ -22,62 +22,62 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - boost::shared_lock lk(m, Clock::now() + ms(750)); + g_t0 = Clock::now(); + boost::shared_lock lk(g_mutex, Clock::now() + ms(750)); BOOST_TEST(lk.owns_lock() == true); - t1 = Clock::now(); + g_t1 = Clock::now(); } void f2() { - t0 = Clock::now(); - boost::shared_lock lk(m, Clock::now() + ms(250)); + g_t0 = Clock::now(); + boost::shared_lock lk(g_mutex, Clock::now() + ms(250)); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp index 5f3036c0ce..8b702ba4a0 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp @@ -21,10 +21,10 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -42,55 +42,55 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::shared_lock lk(m, boost::try_to_lock); + boost::shared_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::shared_lock lk(m, boost::try_to_lock); + boost::shared_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::shared_lock lk(m, boost::try_to_lock); + boost::shared_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } for (;;) { - boost::shared_lock lk(m, boost::try_to_lock); + boost::shared_lock lk(g_mutex, boost::try_to_lock); if (lk.owns_lock()) { - t1 = Clock::now(); + g_t1 = Clock::now(); break; } } #else -// time_point t0 = Clock::now(); +// time_point g_t0 = Clock::now(); // { -// boost::shared_lock lk(m, boost::try_to_lock); +// boost::shared_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::shared_lock lk(m, boost::try_to_lock); +// boost::shared_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::shared_lock lk(m, boost::try_to_lock); +// boost::shared_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } for (;;) { - boost::shared_lock lk(m, boost::try_to_lock); + boost::shared_lock lk(g_mutex, boost::try_to_lock); if (lk.owns_lock()) break; } - //time_point t1 = Clock::now(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -98,12 +98,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp index 456c26dfdd..2dbfb6fd7b 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp @@ -21,11 +21,11 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -33,8 +33,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -43,10 +43,10 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - boost::shared_lock < boost::shared_mutex > lk(m, boost::defer_lock); - t0 = Clock::now(); + boost::shared_lock < boost::shared_mutex > lk(g_mutex, boost::defer_lock); + g_t0 = Clock::now(); lk.lock(); - t1 = Clock::now(); + g_t1 = Clock::now(); BOOST_TEST(lk.owns_lock() == true); try { @@ -69,12 +69,12 @@ void f() BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted); } #else - boost::shared_lock < boost::shared_mutex > lk(m, boost::defer_lock); - //time_point t0 = Clock::now(); + boost::shared_lock < boost::shared_mutex > lk(g_mutex, boost::defer_lock); + //time_point g_t0 = Clock::now(); lk.lock(); - //time_point t1 = Clock::now(); + //time_point g_t1 = Clock::now(); BOOST_TEST(lk.owns_lock() == true); - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); try { @@ -101,7 +101,7 @@ void f() int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -109,12 +109,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp index 07d32df397..0ed6ef086a 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool try_lock_for_called = false; @@ -41,11 +41,11 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::shared_lock lk(m, boost::defer_lock); + boost::shared_lock lk(g_mutex, boost::defer_lock); BOOST_TEST(lk.try_lock_for(ms(5)) == true); BOOST_TEST(try_lock_for_called == true); BOOST_TEST(lk.owns_lock() == true); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp index 6a19972382..d87059dc10 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool try_lock_called = false; @@ -37,11 +37,11 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::shared_lock lk(m, boost::defer_lock); + boost::shared_lock lk(g_mutex, boost::defer_lock); BOOST_TEST(lk.try_lock() == true); BOOST_TEST(try_lock_called == true); BOOST_TEST(lk.owns_lock() == true); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp index cdfd0e1615..528073b634 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp @@ -21,7 +21,12 @@ #include #include -#include +#include +#include +#include + +typedef boost::chrono::steady_clock clock_type; +clock_type::time_point g_abs_timeout; bool try_lock_until_called = false; @@ -30,8 +35,7 @@ struct shared_mutex template bool try_lock_shared_until(const boost::chrono::time_point& abs_time) { - typedef boost::chrono::milliseconds ms; - BOOST_TEST(Clock::now() - abs_time < ms(5)); + BOOST_TEST(abs_time == g_abs_timeout); try_lock_until_called = !try_lock_until_called; return try_lock_until_called; } @@ -40,18 +44,19 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - typedef boost::chrono::steady_clock Clock; - boost::shared_lock lk(m, boost::defer_lock); - BOOST_TEST(lk.try_lock_until(Clock::now()) == true); + boost::shared_lock lk(g_mutex, boost::defer_lock); + g_abs_timeout = clock_type::now(); + BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == true); BOOST_TEST(try_lock_until_called == true); BOOST_TEST(lk.owns_lock() == true); try { - lk.try_lock_until(Clock::now()); + g_abs_timeout = clock_type::now(); + lk.try_lock_until((clock_type::time_point)g_abs_timeout); BOOST_TEST(false); } catch (boost::system::system_error& e) @@ -59,13 +64,15 @@ int main() BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur); } lk.unlock(); - BOOST_TEST(lk.try_lock_until(Clock::now()) == false); + g_abs_timeout = clock_type::now(); + BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == false); BOOST_TEST(try_lock_until_called == false); BOOST_TEST(lk.owns_lock() == false); lk.release(); try { - lk.try_lock_until(Clock::now()); + g_abs_timeout = clock_type::now(); + lk.try_lock_until((clock_type::time_point)g_abs_timeout); BOOST_TEST(false); } catch (boost::system::system_error& e) diff --git a/test/sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp index e8ed7c74cc..e8f528948f 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool unlock_called = false; @@ -36,11 +36,11 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::shared_lock lk(m); + boost::shared_lock lk(g_mutex); lk.unlock(); BOOST_TEST(unlock_called == true); BOOST_TEST(lk.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp index 11f366bd66..4d4a6a1fdb 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp @@ -19,7 +19,7 @@ // void swap(shared_lock& u); #include -#include +#include struct shared_mutex { @@ -31,16 +31,16 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::shared_lock lk1(m); + boost::shared_lock lk1(g_mutex); boost::shared_lock lk2; lk1.swap(lk2); BOOST_TEST(lk1.mutex() == 0); BOOST_TEST(lk1.owns_lock() == false); - BOOST_TEST(lk2.mutex() == &m); + BOOST_TEST(lk2.mutex() == &g_mutex); BOOST_TEST(lk2.owns_lock() == true); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp index c0ccb8b9d2..74d277adad 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp @@ -18,7 +18,7 @@ // void swap(shared_lock& x, shared_lock& y); #include -#include +#include struct shared_mutex { @@ -30,16 +30,16 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::shared_lock lk1(m); + boost::shared_lock lk1(g_mutex); boost::shared_lock lk2; swap(lk1, lk2); BOOST_TEST(lk1.mutex() == 0); BOOST_TEST(lk1.owns_lock() == false); - BOOST_TEST(lk2.mutex() == &m); + BOOST_TEST(lk2.mutex() == &g_mutex); BOOST_TEST(lk2.owns_lock() == true); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp index c39ca50aa0..64b65e20c2 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp @@ -19,7 +19,7 @@ // void Mutex* release(); #include -#include +#include struct shared_mutex { @@ -38,16 +38,16 @@ struct shared_mutex int shared_mutex::lock_count = 0; int shared_mutex::unlock_count = 0; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::shared_lock lk(m); - BOOST_TEST(lk.mutex() == &m); + boost::shared_lock lk(g_mutex); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(shared_mutex::lock_count == 1); BOOST_TEST(shared_mutex::unlock_count == 0); - BOOST_TEST(lk.release() == &m); + BOOST_TEST(lk.release() == &g_mutex); BOOST_TEST(lk.mutex() == 0); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(shared_mutex::lock_count == 1); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp index 2012186ae8..181f74d3ae 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp @@ -20,18 +20,18 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { boost::shared_lock lk0; BOOST_TEST(lk0.mutex() == 0); - boost::shared_lock lk1(m); - BOOST_TEST(lk1.mutex() == &m); + boost::shared_lock lk1(g_mutex); + BOOST_TEST(lk1.mutex() == &g_mutex); lk1.unlock(); - BOOST_TEST(lk1.mutex() == &m); + BOOST_TEST(lk1.mutex() == &g_mutex); return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp index 407bfcc6f0..bd1db334ce 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp @@ -20,15 +20,15 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { boost::shared_lock < boost::shared_mutex > lk0; BOOST_TEST(bool(lk0) == false); - boost::shared_lock < boost::shared_mutex > lk1(m); + boost::shared_lock < boost::shared_mutex > lk1(g_mutex); BOOST_TEST(bool(lk1) == true); lk1.unlock(); BOOST_TEST(bool(lk1) == false); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp index dce14d3e9a..6173b6e11f 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp @@ -20,15 +20,15 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { boost::shared_lock lk0; BOOST_TEST(lk0.owns_lock() == false); - boost::shared_lock lk1(m); + boost::shared_lock lk1(g_mutex); BOOST_TEST(lk1.owns_lock() == true); lk1.unlock(); BOOST_TEST(lk1.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp index 2f83ef98ff..73f96466df 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp @@ -28,7 +28,8 @@ #include #include #include -#include +#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/shared_lock_guard/adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock_guard/adopt_lock_pass.cpp index fe125e8a03..3f0518112c 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock_guard/adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock_guard/adopt_lock_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include "../../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO @@ -30,40 +30,40 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif -boost::shared_mutex m; +boost::shared_mutex g_mutex; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - m.lock_shared(); - boost::shared_lock_guard lg(m, boost::adopt_lock); - t1 = Clock::now(); + g_mutex.lock_shared(); + boost::shared_lock_guard lg(g_mutex, boost::adopt_lock); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - m.lock_shared(); - boost::shared_lock_guard lg(m, boost::adopt_lock); - //t1 = Clock::now(); + g_mutex.lock_shared(); + boost::shared_lock_guard lg(g_mutex, boost::adopt_lock); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -71,12 +71,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_assign_fail.cpp index 43607ac264..d22c8a51a4 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_assign_fail.cpp @@ -20,18 +20,17 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { - boost::shared_lock_guard lk0(m0); - boost::shared_lock_guard lk1(m1); + boost::shared_lock_guard lk0(g_mutex0); + boost::shared_lock_guard lk1(g_mutex1); lk1 = lk0; - + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_ctor_fail.cpp index a7d4f006d7..b4bb6db958 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock_guard/copy_ctor_fail.cpp @@ -21,16 +21,15 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; int main() { - boost::shared_lock_guard lk0(m0); + boost::shared_lock_guard lk0(g_mutex0); boost::shared_lock_guard lk1 = lk0; + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/shared_lock_guard/default_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock_guard/default_pass.cpp index 694ba4a147..c5c484b7ce 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock_guard/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock_guard/default_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include "../../../../timming.hpp" @@ -31,38 +31,38 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif -boost::shared_mutex m; +boost::shared_mutex g_mutex; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::shared_lock_guard lg(m); - t1 = Clock::now(); + boost::shared_lock_guard lg(g_mutex); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - boost::shared_lock_guard lg(m); - //t1 = Clock::now(); + boost::shared_lock_guard lg(g_mutex); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -70,12 +70,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/shared_lock_guard/types_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock_guard/types_pass.cpp index 57a2116d13..cc5a312d4d 100644 --- a/test/sync/mutual_exclusion/locks/shared_lock_guard/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock_guard/types_pass.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/strict_lock/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/strict_lock/copy_assign_fail.cpp index 1852224bb5..b4aac197b9 100644 --- a/test/sync/mutual_exclusion/locks/strict_lock/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/strict_lock/copy_assign_fail.cpp @@ -11,18 +11,17 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; +boost::mutex g_mutex1; int main() { - boost::strict_lock lk0(m0); - boost::strict_lock lk1(m1); + boost::strict_lock lk0(g_mutex0); + boost::strict_lock lk1(g_mutex1); lk1 = lk0; - + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/strict_lock/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/strict_lock/copy_ctor_fail.cpp index 331610cb1d..77ecb21282 100644 --- a/test/sync/mutual_exclusion/locks/strict_lock/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/strict_lock/copy_ctor_fail.cpp @@ -12,15 +12,15 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; int main() { - boost::strict_lock lk0(m0); + boost::strict_lock lk0(g_mutex0); boost::strict_lock lk1 = lk0; + (void)lk1; } #include "../../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/locks/strict_lock/default_pass.cpp b/test/sync/mutual_exclusion/locks/strict_lock/default_pass.cpp index aa2fb00719..504563fde8 100644 --- a/test/sync/mutual_exclusion/locks/strict_lock/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/strict_lock/default_pass.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -21,49 +21,49 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #ifdef BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::strict_lock lg(m); - t1 = Clock::now(); + boost::strict_lock lg(g_mutex); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - boost::strict_lock lg(m); - //t1 = Clock::now(); + boost::strict_lock lg(g_mutex); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #ifdef BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp b/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp index c5a3069f0e..f0e7015c2f 100644 --- a/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp @@ -14,7 +14,7 @@ #include #include -#include +#include #include "../../../../timming.hpp" #ifdef BOOST_THREAD_USES_CHRONO @@ -23,11 +23,11 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif -boost::mutex m; +boost::mutex g_mutex; #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO @@ -35,12 +35,12 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { - t0 = Clock::now(); + g_t0 = Clock::now(); { - const auto&& lg = boost::make_strict_lock(m); (void)lg; - t1 = Clock::now(); + const auto&& lg = boost::make_strict_lock(g_mutex); (void)lg; + g_t1 = Clock::now(); } - ns d = t1 - t0 - ms(250); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } #endif @@ -50,16 +50,16 @@ int main() #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO { - m.lock(); + g_mutex.lock(); boost::thread t(f); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/strict_lock/owns_lock_pass.cpp b/test/sync/mutual_exclusion/locks/strict_lock/owns_lock_pass.cpp index c0c2ec8619..4e40d0c716 100644 --- a/test/sync/mutual_exclusion/locks/strict_lock/owns_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/strict_lock/owns_lock_pass.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #ifdef BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; diff --git a/test/sync/mutual_exclusion/locks/strict_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/strict_lock/types_pass.cpp index f813e5ca8f..4b546b1a2a 100644 --- a/test/sync/mutual_exclusion/locks/strict_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/strict_lock/types_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp index 42d33378ef..0e705d67e0 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp index d69a1eec72..cd21946baf 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp @@ -20,17 +20,17 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; +boost::mutex g_mutex1; int main() { - boost::unique_lock lk0(m0); - boost::unique_lock lk1(m1); + boost::unique_lock lk0(g_mutex0); + boost::unique_lock lk1(g_mutex1); lk1 = lk0; - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); @@ -38,4 +38,3 @@ int main() } #include "../../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp index 08fc3c344f..1b17c31bbd 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp @@ -21,20 +21,19 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; +boost::mutex g_mutex1; int main() { - boost::unique_lock lk0(m0); + boost::unique_lock lk0(g_mutex0); boost::unique_lock lk1 = lk0; - BOOST_TEST(lk1.mutex() == &m1); + BOOST_TEST(lk1.mutex() == &g_mutex1); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } #include "../../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp index 7989b8173c..d09a2a0a22 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp index 5045af26e9..d855a48552 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp index 19aa0575fe..c41c2f0039 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp @@ -24,65 +24,65 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::timed_mutex m; +boost::timed_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - boost::unique_lock lk(m, ms(750)); + g_t0 = Clock::now(); + boost::unique_lock lk(g_mutex, ms(750)); BOOST_TEST(lk.owns_lock() == true); - t1 = Clock::now(); + g_t1 = Clock::now(); } void f2() { - t0 = Clock::now(); - boost::unique_lock lk(m, ms(250)); + g_t0 = Clock::now(); + boost::unique_lock lk(g_mutex, ms(250)); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_adopt_lock_pass.cpp index 2f385ec875..718ea76198 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_adopt_lock_pass.cpp @@ -12,7 +12,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_defer_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_defer_lock_pass.cpp index e32fad1681..9bea91ee7b 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_defer_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_defer_lock_pass.cpp @@ -14,7 +14,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_mutex_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_mutex_pass.cpp index 97b6255640..ff9e1366bf 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_mutex_pass.cpp @@ -14,12 +14,12 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" //#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO @@ -28,8 +28,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -38,7 +38,7 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) auto @@ -46,12 +46,12 @@ void f() boost::unique_lock #endif //&& - _ = boost::make_unique_lock(m); (void)_; - t1 = Clock::now(); + _ = boost::make_unique_lock(g_mutex); (void)_; + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) auto @@ -59,17 +59,17 @@ void f() boost::unique_lock #endif //&& - _ = boost::make_unique_lock(m); (void)_; - //t1 = Clock::now(); + _ = boost::make_unique_lock(g_mutex); (void)_; + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -77,12 +77,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp index d0149d9063..8038bbb02d 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp @@ -14,10 +14,10 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -25,8 +25,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -36,46 +36,46 @@ void f() { #if defined BOOST_THREAD_USES_CHRONO { - t0 = Clock::now(); + g_t0 = Clock::now(); #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) auto #else boost::unique_lock #endif - lk = boost::make_unique_lock(m, boost::try_to_lock); + lk = boost::make_unique_lock(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0; + g_t1 = Clock::now(); + ns d = g_t1 - g_t0; BOOST_THREAD_TEST_IT(d, ns(max_diff)); } { - t0 = Clock::now(); + g_t0 = Clock::now(); #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) auto #else boost::unique_lock #endif - lk = boost::make_unique_lock(m, boost::try_to_lock); + lk = boost::make_unique_lock(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0; + g_t1 = Clock::now(); + ns d = g_t1 - g_t0; BOOST_THREAD_TEST_IT(d, ns(max_diff)); } { - t0 = Clock::now(); + g_t0 = Clock::now(); #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) auto #else boost::unique_lock #endif - lk = boost::make_unique_lock(m, boost::try_to_lock); + lk = boost::make_unique_lock(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0; + g_t1 = Clock::now(); + ns d = g_t1 - g_t0; BOOST_THREAD_TEST_IT(d, ns(max_diff)); } { - t0 = Clock::now(); + g_t0 = Clock::now(); for (;;) { #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) @@ -83,25 +83,25 @@ void f() #else boost::unique_lock #endif - lk = boost::make_unique_lock(m, boost::try_to_lock); + lk = boost::make_unique_lock(g_mutex, boost::try_to_lock); if (lk.owns_lock()) { - t1 = Clock::now(); + g_t1 = Clock::now(); break; } } } #else -// time_point t0 = Clock::now(); +// time_point g_t0 = Clock::now(); // { -// boost::unique_lock lk(m, boost::try_to_lock); +// boost::unique_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::unique_lock lk(m, boost::try_to_lock); +// boost::unique_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::unique_lock lk(m, boost::try_to_lock); +// boost::unique_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } for (;;) @@ -111,18 +111,18 @@ void f() #else boost::unique_lock #endif - lk = boost::make_unique_lock(m, boost::try_to_lock); + lk = boost::make_unique_lock(g_mutex, boost::try_to_lock); if (lk.owns_lock()) break; } - //time_point t1 = Clock::now(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -130,12 +130,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_locks_mutex_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_locks_mutex_pass.cpp index 72c574b200..3d0dcc28fb 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_locks_mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_locks_mutex_pass.cpp @@ -13,14 +13,14 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS && ! defined BOOST_NO_CXX11_RVALUE_REFERENCES -boost::mutex m1; -boost::mutex m2; -boost::mutex m3; +boost::mutex g_mutex1; +boost::mutex g_mutex2; +boost::mutex g_mutex3; #if defined BOOST_THREAD_USES_CHRONO @@ -30,8 +30,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -40,28 +40,28 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - auto&& _ = boost::make_unique_locks(m1,m2,m3); (void)_; - t1 = Clock::now(); + auto&& _ = boost::make_unique_locks(g_mutex1,g_mutex2,g_mutex3); (void)_; + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - auto&& _ = boost::make_unique_locks(m1,m2,m3); (void)_; - //t1 = Clock::now(); + auto&& _ = boost::make_unique_locks(g_mutex1,g_mutex2,g_mutex3); (void)_; + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m1.lock(); - m2.lock(); - m3.lock(); + g_mutex1.lock(); + g_mutex2.lock(); + g_mutex3.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -69,14 +69,14 @@ int main() time_point t3 = Clock::now(); #else #endif - m1.unlock(); - m2.unlock(); - m3.unlock(); + g_mutex1.unlock(); + g_mutex2.unlock(); + g_mutex3.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp index 7c84d15202..163cf54f31 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp @@ -21,32 +21,28 @@ #include #include -#include +#include -boost::mutex m0; -boost::mutex m1; +boost::mutex g_mutex0; +boost::mutex g_mutex1; int main() { { - boost::unique_lock lk0(m0); - boost::unique_lock lk1(m1); + boost::unique_lock lk0(g_mutex0); + boost::unique_lock lk1(g_mutex1); lk1 = boost::move(lk0); - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } - - { - boost::unique_lock lk1; - lk1 = BOOST_THREAD_MAKE_RV_REF(boost::unique_lock(m0)); - BOOST_TEST(lk1.mutex() == &m0); + lk1 = BOOST_THREAD_MAKE_RV_REF(boost::unique_lock(g_mutex0)); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); } - return boost::report_errors(); + return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp index cf682fbd47..ce9d8a557e 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp @@ -21,35 +21,35 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; int main() { { - boost::unique_lock lk0(m); + boost::unique_lock lk0(g_mutex); boost::unique_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::unique_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::unique_lock(m)))); - BOOST_TEST(lk.mutex() == &m); + boost::unique_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::unique_lock(g_mutex)))); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::unique_lock lk0(m, boost::defer_lock); + boost::unique_lock lk0(g_mutex, boost::defer_lock); boost::unique_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::unique_lock lk0(m, boost::defer_lock); + boost::unique_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::unique_lock lk( (boost::move(lk0))); BOOST_TEST(lk.mutex() == 0); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_for_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_for_pass.cpp index 0e61cb1a75..84ae7b1a09 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_for_pass.cpp @@ -26,36 +26,36 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); + boost::shared_lock lk0(g_mutex); boost::unique_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { boost::unique_lock - lk(boost::shared_lock(m), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + lk(boost::shared_lock(g_mutex), boost::chrono::milliseconds(1)); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); boost::unique_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::unique_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); BOOST_TEST(lk.mutex() == 0); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_try_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_try_pass.cpp index 3068866f00..35db880786 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_try_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_try_pass.cpp @@ -24,43 +24,42 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); - boost::unique_lock lk(boost::move(lk0), boost::try_to_lock ); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex); + boost::unique_lock lk(boost::move(lk0), boost::try_to_lock ); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::unique_lock lk(boost::shared_lock(m), boost::try_to_lock); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::unique_lock lk(boost::shared_lock(g_mutex), boost::try_to_lock); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } { - boost::shared_lock lk0(m, boost::defer_lock); - boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex, boost::defer_lock); + boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk0(m, boost::defer_lock); - lk0.release(); - boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); - BOOST_TEST(lk.mutex() == 0); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex, boost::defer_lock); + lk0.release(); + boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); + BOOST_TEST(lk.mutex() == 0); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_until_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_until_pass.cpp index f1e54cf45a..b9b60c1db8 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_shared_lock_until_pass.cpp @@ -26,36 +26,36 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); + boost::shared_lock lk0(g_mutex); boost::unique_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { boost::unique_lock - lk( boost::shared_lock(m), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + lk( boost::shared_lock(g_mutex), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); boost::unique_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::unique_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); BOOST_TEST(lk.mutex() == 0); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_for_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_for_pass.cpp index 7437ee0e7d..0c258fd830 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_for_pass.cpp @@ -24,36 +24,36 @@ #include #include -#include +#include -boost::upgrade_mutex m; +boost::upgrade_mutex g_mutex; int main() { { - boost::upgrade_lock lk0(m); + boost::upgrade_lock lk0(g_mutex); boost::unique_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { boost::unique_lock - lk(boost::upgrade_lock(m), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + lk(boost::upgrade_lock(g_mutex), boost::chrono::milliseconds(1)); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::upgrade_lock lk0(m, boost::defer_lock); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); boost::unique_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk0(m, boost::defer_lock); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::unique_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); BOOST_TEST(lk.mutex() == 0); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_pass.cpp index c72067ae90..944075c068 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_pass.cpp @@ -21,41 +21,41 @@ #include #include -#include +#include -boost::upgrade_mutex m; +boost::upgrade_mutex g_mutex; int main() { { - boost::upgrade_lock lk0(m); - boost::unique_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex); + boost::unique_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::unique_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(m)))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::unique_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(g_mutex)))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } { - boost::upgrade_lock lk0(m, boost::defer_lock); - boost::unique_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); + boost::unique_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk0(m, boost::defer_lock); - lk0.release(); - boost::unique_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == 0); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); + lk0.release(); + boost::unique_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == 0); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_try_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_try_pass.cpp index fdbdf21655..6948fabb4b 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_try_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_try_pass.cpp @@ -22,43 +22,42 @@ #include #include -#include +#include -boost::upgrade_mutex m; +boost::upgrade_mutex g_mutex; int main() { { - boost::upgrade_lock lk0(m); - boost::unique_lock lk(boost::move(lk0), boost::try_to_lock ); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex); + boost::unique_lock lk(boost::move(lk0), boost::try_to_lock ); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::unique_lock lk(boost::upgrade_lock(m), boost::try_to_lock); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::unique_lock lk(boost::upgrade_lock(g_mutex), boost::try_to_lock); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } { - boost::upgrade_lock lk0(m, boost::defer_lock); - boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); + boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk0(m, boost::defer_lock); - lk0.release(); - boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); - BOOST_TEST(lk.mutex() == 0); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); + lk0.release(); + boost::unique_lock lk(boost::move(lk0), boost::try_to_lock); + BOOST_TEST(lk.mutex() == 0); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_until_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_until_pass.cpp index cd33f709cd..c0467b2de6 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_until_pass.cpp @@ -24,36 +24,36 @@ #include #include -#include +#include -boost::upgrade_mutex m; +boost::upgrade_mutex g_mutex; int main() { { - boost::upgrade_lock lk0(m); + boost::upgrade_lock lk0(g_mutex); boost::unique_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { boost::unique_lock - lk( boost::upgrade_lock(m), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + lk( boost::upgrade_lock(g_mutex), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::upgrade_lock lk0(m, boost::defer_lock); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); boost::unique_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk0(m, boost::defer_lock); + boost::upgrade_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::unique_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); BOOST_TEST(lk.mutex() == 0); @@ -64,4 +64,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp index d5b7ca2957..93c95ededb 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp @@ -22,12 +22,12 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -35,8 +35,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -45,26 +45,26 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::unique_lock ul(m); - t1 = Clock::now(); + boost::unique_lock ul(g_mutex); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - boost::unique_lock ul(m); - //t1 = Clock::now(); + boost::unique_lock ul(g_mutex); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -72,12 +72,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp index 53358de6e2..8286208637 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp @@ -24,64 +24,64 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::timed_mutex m; +boost::timed_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - boost::unique_lock lk(m, Clock::now() + ms(750)); + g_t0 = Clock::now(); + boost::unique_lock lk(g_mutex, Clock::now() + ms(750)); BOOST_TEST(lk.owns_lock() == true); - t1 = Clock::now(); + g_t1 = Clock::now(); } void f2() { - t0 = Clock::now(); - boost::unique_lock lk(m, Clock::now() + ms(250)); + g_t0 = Clock::now(); + boost::unique_lock lk(g_mutex, Clock::now() + ms(250)); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_TEST(d < max_diff); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp index 0f0c8ded4b..4d74eb4b7c 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp @@ -22,11 +22,11 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -34,8 +34,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -44,56 +44,56 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::unique_lock lk(m, boost::try_to_lock); + boost::unique_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::unique_lock lk(m, boost::try_to_lock); + boost::unique_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::unique_lock lk(m, boost::try_to_lock); + boost::unique_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } for (;;) { - boost::unique_lock lk(m, boost::try_to_lock); + boost::unique_lock lk(g_mutex, boost::try_to_lock); if (lk.owns_lock()) { - t1 = Clock::now(); + g_t1 = Clock::now(); break; } } - //m.unlock(); + //g_mutex.unlock(); #else -// time_point t0 = Clock::now(); +// time_point g_t0 = Clock::now(); // { -// boost::unique_lock lk(m, boost::try_to_lock); +// boost::unique_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::unique_lock lk(m, boost::try_to_lock); +// boost::unique_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::unique_lock lk(m, boost::try_to_lock); +// boost::unique_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } for (;;) { - boost::unique_lock lk(m, boost::try_to_lock); + boost::unique_lock lk(g_mutex, boost::try_to_lock); if (lk.owns_lock()) break; } - //time_point t1 = Clock::now(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -101,12 +101,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); std::cout << "d_ns: " << d_ns.count() << std::endl; std::cout << "d_ms: " << d_ms.count() << std::endl; diff --git a/test/sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp index 94edb4342e..c67be07ba5 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp @@ -21,11 +21,11 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -33,8 +33,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -43,10 +43,10 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - boost::unique_lock < boost::mutex > lk(m, boost::defer_lock); - t0 = Clock::now(); + boost::unique_lock < boost::mutex > lk(g_mutex, boost::defer_lock); + g_t0 = Clock::now(); lk.lock(); - t1 = Clock::now(); + g_t1 = Clock::now(); BOOST_TEST(lk.owns_lock() == true); try { @@ -69,12 +69,12 @@ void f() BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted); } #else - boost::unique_lock < boost::mutex > lk(m, boost::defer_lock); - //time_point t0 = Clock::now(); + boost::unique_lock < boost::mutex > lk(g_mutex, boost::defer_lock); + //time_point g_t0 = Clock::now(); lk.lock(); - //time_point t1 = Clock::now(); + //time_point g_t1 = Clock::now(); BOOST_TEST(lk.owns_lock() == true); - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); try { @@ -101,7 +101,7 @@ void f() int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -109,12 +109,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp index 2be8416eb5..172d78bb03 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include #if defined BOOST_THREAD_USES_CHRONO @@ -44,11 +44,11 @@ struct mutex } }; -mutex m; +mutex g_mutex; int main() { - boost::unique_lock lk(m, boost::defer_lock); + boost::unique_lock lk(g_mutex, boost::defer_lock); BOOST_TEST(lk.try_lock_for(ms(5)) == true); BOOST_TEST(try_lock_for_called == true); BOOST_TEST(lk.owns_lock() == true); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp index 8553c1c0b0..3d40d4ca6d 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool try_lock_called = false; @@ -37,11 +37,11 @@ struct mutex } }; -mutex m; +mutex g_mutex; int main() { - boost::unique_lock lk(m, boost::defer_lock); + boost::unique_lock lk(g_mutex, boost::defer_lock); BOOST_TEST(lk.try_lock() == true); BOOST_TEST(try_lock_called == true); BOOST_TEST(lk.owns_lock() == true); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp index df6e7369ea..90af57296c 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp @@ -21,10 +21,15 @@ #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO +#include +#include + +typedef boost::chrono::steady_clock clock_type; +clock_type::time_point g_abs_timeout; bool try_lock_until_called = false; @@ -33,8 +38,7 @@ struct mutex template bool try_lock_until(const boost::chrono::time_point& abs_time) { - typedef boost::chrono::milliseconds ms; - BOOST_TEST(Clock::now() - abs_time < ms(5)); + BOOST_TEST(abs_time == g_abs_timeout); try_lock_until_called = !try_lock_until_called; return try_lock_until_called; } @@ -43,18 +47,19 @@ struct mutex } }; -mutex m; +mutex g_mutex; int main() { - typedef boost::chrono::steady_clock Clock; - boost::unique_lock lk(m, boost::defer_lock); - BOOST_TEST(lk.try_lock_until(Clock::now()) == true); + boost::unique_lock lk(g_mutex, boost::defer_lock); + g_abs_timeout = clock_type::now(); + BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == true); BOOST_TEST(try_lock_until_called == true); BOOST_TEST(lk.owns_lock() == true); try { - lk.try_lock_until(Clock::now()); + g_abs_timeout = clock_type::now(); + lk.try_lock_until((clock_type::time_point)g_abs_timeout); BOOST_TEST(false); } catch (boost::system::system_error& e) @@ -62,13 +67,15 @@ int main() BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur); } lk.unlock(); - BOOST_TEST(lk.try_lock_until(Clock::now()) == false); + g_abs_timeout = clock_type::now(); + BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == false); BOOST_TEST(try_lock_until_called == false); BOOST_TEST(lk.owns_lock() == false); lk.release(); try { - lk.try_lock_until(Clock::now()); + g_abs_timeout = clock_type::now(); + lk.try_lock_until((clock_type::time_point)g_abs_timeout); BOOST_TEST(false); } catch (boost::system::system_error& e) @@ -81,4 +88,3 @@ int main() #else #error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported" #endif - diff --git a/test/sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp index 4ad954f247..96e9c265b7 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp @@ -20,7 +20,7 @@ #include //#include -#include +#include bool unlock_called = false; @@ -36,11 +36,11 @@ struct mutex } }; -mutex m; +mutex g_mutex; int main() { - boost::unique_lock lk(m); + boost::unique_lock lk(g_mutex); lk.unlock(); BOOST_TEST(unlock_called == true); BOOST_TEST(lk.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp index 617682fe39..470600bf5f 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp @@ -19,7 +19,7 @@ // void swap(unique_lock& u); #include -#include +#include struct mutex { @@ -31,16 +31,16 @@ struct mutex } }; -mutex m; +mutex g_mutex; int main() { - boost::unique_lock lk1(m); + boost::unique_lock lk1(g_mutex); boost::unique_lock lk2; lk1.swap(lk2); BOOST_TEST(lk1.mutex() == 0); BOOST_TEST(lk1.owns_lock() == false); - BOOST_TEST(lk2.mutex() == &m); + BOOST_TEST(lk2.mutex() == &g_mutex); BOOST_TEST(lk2.owns_lock() == true); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp index 74ba5ff3ff..405c646caf 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp @@ -18,7 +18,7 @@ // void swap(unique_lock& x, unique_lock& y); #include -#include +#include struct mutex { @@ -30,16 +30,16 @@ struct mutex } }; -mutex m; +mutex g_mutex; int main() { - boost::unique_lock lk1(m); + boost::unique_lock lk1(g_mutex); boost::unique_lock lk2; swap(lk1, lk2); BOOST_TEST(lk1.mutex() == 0); BOOST_TEST(lk1.owns_lock() == false); - BOOST_TEST(lk2.mutex() == &m); + BOOST_TEST(lk2.mutex() == &g_mutex); BOOST_TEST(lk2.owns_lock() == true); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp index 63c3831e52..6e359cbb51 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp @@ -19,7 +19,7 @@ // void Mutex* release(); #include -#include +#include struct mutex { @@ -38,16 +38,16 @@ struct mutex int mutex::lock_count = 0; int mutex::unlock_count = 0; -mutex m; +mutex g_mutex; int main() { - boost::unique_lock lk(m); - BOOST_TEST(lk.mutex() == &m); + boost::unique_lock lk(g_mutex); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(mutex::lock_count == 1); BOOST_TEST(mutex::unlock_count == 0); - BOOST_TEST(lk.release() == &m); + BOOST_TEST(lk.release() == &g_mutex); BOOST_TEST(lk.mutex() == 0); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(mutex::lock_count == 1); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp index 68f1bbb6d1..a615773a0a 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp @@ -20,18 +20,18 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; int main() { boost::unique_lock lk0; BOOST_TEST(lk0.mutex() == 0); - boost::unique_lock lk1(m); - BOOST_TEST(lk1.mutex() == &m); + boost::unique_lock lk1(g_mutex); + BOOST_TEST(lk1.mutex() == &g_mutex); lk1.unlock(); - BOOST_TEST(lk1.mutex() == &m); + BOOST_TEST(lk1.mutex() == &g_mutex); return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp index 3fa18225a8..289aa23fb8 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp @@ -20,16 +20,16 @@ #include #include -#include +#include -boost::mutex m; +boost::mutex g_mutex; int main() { { boost::unique_lock lk0; BOOST_TEST(bool(lk0) == false); - boost::unique_lock lk1(m); + boost::unique_lock lk1(g_mutex); BOOST_TEST(bool(lk1) == true); lk1.unlock(); BOOST_TEST(bool(lk1) == false); @@ -38,7 +38,7 @@ int main() { boost::unique_lock lk0; if (lk0) BOOST_TEST(false); - boost::unique_lock lk1(m); + boost::unique_lock lk1(g_mutex); if (!lk1) BOOST_TEST(false); lk1.unlock(); if (lk1) BOOST_TEST(false); diff --git a/test/sync/mutual_exclusion/locks/unique_lock/obs/op_int_fail.cpp b/test/sync/mutual_exclusion/locks/unique_lock/obs/op_int_fail.cpp index 92fe0ffcb9..7bb2cb2833 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/obs/op_int_fail.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/obs/op_int_fail.cpp @@ -20,9 +20,7 @@ #include #include -#include - -boost::mutex m; +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp index 6a9f019aa4..380e91430d 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() diff --git a/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp index 69b963a6f0..e00f550793 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp @@ -28,7 +28,8 @@ #include #include #include -#include +#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp index 1822fe0b63..7849c14927 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include int main() diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp index 521304d817..f26ff90c3f 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp @@ -20,17 +20,17 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { - boost::upgrade_lock lk0(m0); - boost::upgrade_lock lk1(m1); + boost::upgrade_lock lk0(g_mutex0); + boost::upgrade_lock lk1(g_mutex1); lk1 = lk0; - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); @@ -38,4 +38,3 @@ int main() } #include "../../../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp index 8e20196b1f..bc166d9af1 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp @@ -21,16 +21,16 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { - boost::upgrade_lock lk0(m0); + boost::upgrade_lock lk0(g_mutex0); boost::upgrade_lock lk1(lk0); - BOOST_TEST(lk1.mutex() == &m1); + BOOST_TEST(lk1.mutex() == &g_mutex1); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp index 59ea2a9a2a..983264b421 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp index ececb845c9..4902cd2a37 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp index b6506b9b32..804f0f5384 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp @@ -24,66 +24,65 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - boost::upgrade_lock lk(m, ms(750)); + g_t0 = Clock::now(); + boost::upgrade_lock lk(g_mutex, ms(750)); BOOST_TEST(lk.owns_lock() == true); - t1 = Clock::now(); + g_t1 = Clock::now(); } void f2() { - t0 = Clock::now(); - boost::upgrade_lock lk(m, ms(250)); + g_t0 = Clock::now(); + boost::upgrade_lock lk(g_mutex, ms(250)); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp index 42ef355c9a..d642c33eaf 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp @@ -21,46 +21,43 @@ #include #include -#include +#include -boost::shared_mutex m0; -boost::shared_mutex m1; +boost::shared_mutex g_mutex0; +boost::shared_mutex g_mutex1; int main() { { - boost::upgrade_lock lk0(m0); - boost::upgrade_lock lk1(m1); + boost::upgrade_lock lk0(g_mutex0); + boost::upgrade_lock lk1(g_mutex1); lk1 = boost::move(lk0); - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk1; - lk1 = BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(m0)); - BOOST_TEST(lk1.mutex() == &m0); + lk1 = BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(g_mutex0)); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); } { - boost::unique_lock lk0(m0); - boost::upgrade_lock lk1(m1); + boost::unique_lock lk0(g_mutex0); + boost::upgrade_lock lk1(g_mutex1); lk1 = BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(boost::move(lk0))); - BOOST_TEST(lk1.mutex() == &m0); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk1; - lk1 = BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(boost::unique_lock(m0))); - BOOST_TEST(lk1.mutex() == &m0); + lk1 = BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(boost::unique_lock(g_mutex0))); + BOOST_TEST(lk1.mutex() == &g_mutex0); BOOST_TEST(lk1.owns_lock() == true); } - return boost::report_errors(); + return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp index 5d5c0a9482..9151e1445c 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp @@ -21,23 +21,23 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::upgrade_lock lk0(m); + boost::upgrade_lock lk0(g_mutex); boost::upgrade_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(m)))); - BOOST_TEST(lk.mutex() == &m); + boost::upgrade_lock lk( (BOOST_THREAD_MAKE_RV_REF(boost::upgrade_lock(g_mutex)))); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_for_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_for_pass.cpp index ccad7b1ac9..e0e7e054e7 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_for_pass.cpp @@ -26,36 +26,36 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); + boost::shared_lock lk0(g_mutex); boost::upgrade_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { boost::upgrade_lock - lk(boost::shared_lock(m), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + lk(boost::shared_lock(g_mutex), boost::chrono::milliseconds(1)); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); boost::upgrade_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::upgrade_lock lk(boost::move(lk0), boost::chrono::milliseconds(1)); BOOST_TEST(lk.mutex() == 0); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_try_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_try_pass.cpp index 93deda8c33..429043d861 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_try_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_try_pass.cpp @@ -24,43 +24,42 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); - boost::upgrade_lock lk(boost::move(lk0), boost::try_to_lock ); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex); + boost::upgrade_lock lk(boost::move(lk0), boost::try_to_lock ); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk(boost::shared_lock(m), boost::try_to_lock); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::upgrade_lock lk(boost::shared_lock(g_mutex), boost::try_to_lock); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } { - boost::shared_lock lk0(m, boost::defer_lock); - boost::upgrade_lock lk(boost::move(lk0), boost::try_to_lock); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex, boost::defer_lock); + boost::upgrade_lock lk(boost::move(lk0), boost::try_to_lock); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk0(m, boost::defer_lock); - lk0.release(); - boost::upgrade_lock lk(boost::move(lk0), boost::try_to_lock); - BOOST_TEST(lk.mutex() == 0); - BOOST_TEST(lk.owns_lock() == false); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::shared_lock lk0(g_mutex, boost::defer_lock); + lk0.release(); + boost::upgrade_lock lk(boost::move(lk0), boost::try_to_lock); + BOOST_TEST(lk.mutex() == 0); + BOOST_TEST(lk.owns_lock() == false); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_until_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_until_pass.cpp index 3d2c2871b7..37c9ba36ea 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_shared_lock_until_pass.cpp @@ -26,36 +26,36 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::shared_lock lk0(m); + boost::shared_lock lk0(g_mutex); boost::upgrade_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { boost::upgrade_lock - lk( boost::shared_lock(m), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + lk( boost::shared_lock(g_mutex), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); boost::upgrade_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); - BOOST_TEST(lk.mutex() == &m); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(lk0.mutex() == 0); BOOST_TEST(lk0.owns_lock() == false); } { - boost::shared_lock lk0(m, boost::defer_lock); + boost::shared_lock lk0(g_mutex, boost::defer_lock); lk0.release(); boost::upgrade_lock lk( boost::move(lk0), boost::chrono::steady_clock::now()+boost::chrono::milliseconds(1)); BOOST_TEST(lk.mutex() == 0); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_unique_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_unique_lock_pass.cpp index 3d591d1761..9df338d61e 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_unique_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_unique_lock_pass.cpp @@ -21,24 +21,24 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { { - boost::unique_lock lk0(m); - boost::upgrade_lock lk( (boost::move(lk0))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); - BOOST_TEST(lk0.mutex() == 0); - BOOST_TEST(lk0.owns_lock() == false); + boost::unique_lock lk0(g_mutex); + boost::upgrade_lock lk( (boost::move(lk0))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); + BOOST_TEST(lk0.mutex() == 0); + BOOST_TEST(lk0.owns_lock() == false); } { - boost::upgrade_lock lk( (boost::unique_lock(m))); - BOOST_TEST(lk.mutex() == &m); - BOOST_TEST(lk.owns_lock() == true); + boost::upgrade_lock lk( (boost::unique_lock(g_mutex))); + BOOST_TEST(lk.mutex() == &g_mutex); + BOOST_TEST(lk.owns_lock() == true); } return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp index 1e634807db..52f969ebd9 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp @@ -22,11 +22,11 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -34,8 +34,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -44,26 +44,26 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::upgrade_lock ul(m); - t1 = Clock::now(); + boost::upgrade_lock ul(g_mutex); + g_t1 = Clock::now(); } #else - //time_point t0 = Clock::now(); - //time_point t1; + //time_point g_t0 = Clock::now(); + //time_point g_t1; { - boost::upgrade_lock ul(m); - //t1 = Clock::now(); + boost::upgrade_lock ul(g_mutex); + //g_t1 = Clock::now(); } - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -71,12 +71,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp index 4cf71476b2..bda497f8cf 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp @@ -24,62 +24,62 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - boost::upgrade_lock lk(m, Clock::now() + ms(750)); + g_t0 = Clock::now(); + boost::upgrade_lock lk(g_mutex, Clock::now() + ms(750)); BOOST_TEST(lk.owns_lock() == true); - t1 = Clock::now(); + g_t1 = Clock::now(); } void f2() { - t0 = Clock::now(); - boost::upgrade_lock lk(m, Clock::now() + ms(250)); + g_t0 = Clock::now(); + boost::upgrade_lock lk(g_mutex, Clock::now() + ms(250)); BOOST_TEST(lk.owns_lock() == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp index 9a7fe26bff..18e982597d 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp @@ -22,10 +22,10 @@ #include #include #include -#include +#include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -33,8 +33,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -43,56 +43,56 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); + g_t0 = Clock::now(); { - boost::upgrade_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::upgrade_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::upgrade_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(g_mutex, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } for (;;) { - boost::upgrade_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(g_mutex, boost::try_to_lock); if (lk.owns_lock()) { - t1 = Clock::now(); + g_t1 = Clock::now(); break; } } - //m.unlock(); + //g_mutex.unlock(); #else -// time_point t0 = Clock::now(); +// time_point g_t0 = Clock::now(); // { -// boost::upgrade_lock lk(m, boost::try_to_lock); +// boost::upgrade_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::upgrade_lock lk(m, boost::try_to_lock); +// boost::upgrade_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } // { -// boost::upgrade_lock lk(m, boost::try_to_lock); +// boost::upgrade_lock lk(g_mutex, boost::try_to_lock); // BOOST_TEST(lk.owns_lock() == false); // } for (;;) { - boost::upgrade_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(g_mutex, boost::try_to_lock); if (lk.owns_lock()) break; } - //time_point t1 = Clock::now(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -100,12 +100,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp index 2ff49ac96e..bda975398e 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp @@ -21,11 +21,11 @@ #include #include #include -#include +#include #include #include "../../../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -33,8 +33,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -43,10 +43,10 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - boost::upgrade_lock < boost::shared_mutex > lk(m, boost::defer_lock); - t0 = Clock::now(); + boost::upgrade_lock < boost::shared_mutex > lk(g_mutex, boost::defer_lock); + g_t0 = Clock::now(); lk.lock(); - t1 = Clock::now(); + g_t1 = Clock::now(); BOOST_TEST(lk.owns_lock() == true); try { @@ -69,12 +69,12 @@ void f() BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted); } #else - boost::upgrade_lock < boost::shared_mutex > lk(m, boost::defer_lock); - //time_point t0 = Clock::now(); + boost::upgrade_lock < boost::shared_mutex > lk(g_mutex, boost::defer_lock); + //time_point g_t0 = Clock::now(); lk.lock(); - //time_point t1 = Clock::now(); + //time_point g_t1 = Clock::now(); BOOST_TEST(lk.owns_lock() == true); - //ns d = t1 - t0 - ms(250); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); try { @@ -101,7 +101,7 @@ void f() int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -109,12 +109,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp index 5f8f4f5fec..04d080651a 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool try_lock_for_called = false; @@ -41,11 +41,11 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::upgrade_lock lk(m, boost::defer_lock); + boost::upgrade_lock lk(g_mutex, boost::defer_lock); BOOST_TEST(lk.try_lock_for(ms(5)) == true); BOOST_TEST(try_lock_for_called == true); BOOST_TEST(lk.owns_lock() == true); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp index 820fd71a36..d2da94afac 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool try_lock_called = false; @@ -37,11 +37,11 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::upgrade_lock lk(m, boost::defer_lock); + boost::upgrade_lock lk(g_mutex, boost::defer_lock); BOOST_TEST(lk.try_lock() == true); BOOST_TEST(try_lock_called == true); BOOST_TEST(lk.owns_lock() == true); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp index 1c53d6a5bc..3ec7886090 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp @@ -21,7 +21,12 @@ #include #include -#include +#include +#include +#include + +typedef boost::chrono::steady_clock clock_type; +clock_type::time_point g_abs_timeout; bool try_lock_until_called = false; @@ -30,8 +35,7 @@ struct shared_mutex template bool try_lock_upgrade_until(const boost::chrono::time_point& abs_time) { - typedef boost::chrono::milliseconds ms; - BOOST_TEST(Clock::now() - abs_time < ms(5)); + BOOST_TEST(abs_time == g_abs_timeout); try_lock_until_called = !try_lock_until_called; return try_lock_until_called; } @@ -40,18 +44,19 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - typedef boost::chrono::steady_clock Clock; - boost::upgrade_lock lk(m, boost::defer_lock); - BOOST_TEST(lk.try_lock_until(Clock::now()) == true); + boost::upgrade_lock lk(g_mutex, boost::defer_lock); + g_abs_timeout = clock_type::now(); + BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == true); BOOST_TEST(try_lock_until_called == true); BOOST_TEST(lk.owns_lock() == true); try { - lk.try_lock_until(Clock::now()); + g_abs_timeout = clock_type::now(); + lk.try_lock_until((clock_type::time_point)g_abs_timeout); BOOST_TEST(false); } catch (boost::system::system_error& e) @@ -59,13 +64,15 @@ int main() BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur); } lk.unlock(); - BOOST_TEST(lk.try_lock_until(Clock::now()) == false); + g_abs_timeout = clock_type::now(); + BOOST_TEST(lk.try_lock_until((clock_type::time_point)g_abs_timeout) == false); BOOST_TEST(try_lock_until_called == false); BOOST_TEST(lk.owns_lock() == false); lk.release(); try { - lk.try_lock_until(Clock::now()); + g_abs_timeout = clock_type::now(); + lk.try_lock_until((clock_type::time_point)g_abs_timeout); BOOST_TEST(false); } catch (boost::system::system_error& e) diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp index bc49a04339..53fbd91b64 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp @@ -21,7 +21,7 @@ #include //#include -#include +#include bool unlock_called = false; @@ -36,11 +36,11 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::upgrade_lock lk(m); + boost::upgrade_lock lk(g_mutex); lk.unlock(); BOOST_TEST(unlock_called == true); BOOST_TEST(lk.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp index 4b0752ef5e..fe1b825e3c 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp @@ -19,7 +19,7 @@ // void swap(upgrade_lock& u); #include -#include +#include struct shared_mutex { @@ -31,16 +31,16 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::upgrade_lock lk1(m); + boost::upgrade_lock lk1(g_mutex); boost::upgrade_lock lk2; lk1.swap(lk2); BOOST_TEST(lk1.mutex() == 0); BOOST_TEST(lk1.owns_lock() == false); - BOOST_TEST(lk2.mutex() == &m); + BOOST_TEST(lk2.mutex() == &g_mutex); BOOST_TEST(lk2.owns_lock() == true); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp index c7ebaa271b..0ef2f766ba 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp @@ -18,7 +18,7 @@ // void swap(upgrade_lock& x, upgrade_lock& y); #include -#include +#include struct shared_mutex { @@ -30,16 +30,16 @@ struct shared_mutex } }; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::upgrade_lock lk1(m); + boost::upgrade_lock lk1(g_mutex); boost::upgrade_lock lk2; swap(lk1, lk2); BOOST_TEST(lk1.mutex() == 0); BOOST_TEST(lk1.owns_lock() == false); - BOOST_TEST(lk2.mutex() == &m); + BOOST_TEST(lk2.mutex() == &g_mutex); BOOST_TEST(lk2.owns_lock() == true); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp index 226819446a..6985dd0206 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp @@ -19,7 +19,7 @@ // void Mutex* release(); #include -#include +#include struct shared_mutex { @@ -38,16 +38,16 @@ struct shared_mutex int shared_mutex::lock_count = 0; int shared_mutex::unlock_count = 0; -shared_mutex m; +shared_mutex g_mutex; int main() { - boost::upgrade_lock lk(m); - BOOST_TEST(lk.mutex() == &m); + boost::upgrade_lock lk(g_mutex); + BOOST_TEST(lk.mutex() == &g_mutex); BOOST_TEST(lk.owns_lock() == true); BOOST_TEST(shared_mutex::lock_count == 1); BOOST_TEST(shared_mutex::unlock_count == 0); - BOOST_TEST(lk.release() == &m); + BOOST_TEST(lk.release() == &g_mutex); BOOST_TEST(lk.mutex() == 0); BOOST_TEST(lk.owns_lock() == false); BOOST_TEST(shared_mutex::lock_count == 1); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp index 276cd0a932..e05e3b3795 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp @@ -20,18 +20,18 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { boost::upgrade_lock lk0; BOOST_TEST(lk0.mutex() == 0); - boost::upgrade_lock lk1(m); - BOOST_TEST(lk1.mutex() == &m); + boost::upgrade_lock lk1(g_mutex); + BOOST_TEST(lk1.mutex() == &g_mutex); lk1.unlock(); - BOOST_TEST(lk1.mutex() == &m); + BOOST_TEST(lk1.mutex() == &g_mutex); return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp index 4e722d174f..8291547309 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp @@ -20,15 +20,15 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { boost::upgrade_lock < boost::shared_mutex > lk0; BOOST_TEST(bool(lk0) == false); - boost::upgrade_lock < boost::shared_mutex > lk1(m); + boost::upgrade_lock < boost::shared_mutex > lk1(g_mutex); BOOST_TEST(bool(lk1) == true); lk1.unlock(); BOOST_TEST(bool(lk1) == false); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp index 9d8b80d697..81a148e67a 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp @@ -20,15 +20,15 @@ #include #include -#include +#include -boost::shared_mutex m; +boost::shared_mutex g_mutex; int main() { boost::upgrade_lock lk0; BOOST_TEST(lk0.owns_lock() == false); - boost::upgrade_lock lk1(m); + boost::upgrade_lock lk1(g_mutex); BOOST_TEST(lk1.owns_lock() == true); lk1.unlock(); BOOST_TEST(lk1.owns_lock() == false); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp index 876428e465..f1bc6410ca 100644 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp @@ -28,7 +28,8 @@ #include #include #include -#include +#include +#include int main() { diff --git a/test/sync/mutual_exclusion/mutex/assign_fail.cpp b/test/sync/mutual_exclusion/mutex/assign_fail.cpp index fa1aff9b58..30508dbf29 100644 --- a/test/sync/mutual_exclusion/mutex/assign_fail.cpp +++ b/test/sync/mutual_exclusion/mutex/assign_fail.cpp @@ -19,12 +19,14 @@ // mutex& operator=(const mutex&) = delete; #include -#include +#include int main() { boost::mutex m0; - boost::mutex m1(m0); + boost::mutex m1; + m1 = m0; + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/mutex/copy_fail.cpp b/test/sync/mutual_exclusion/mutex/copy_fail.cpp index e6f6d6b88a..d6b1d4321f 100644 --- a/test/sync/mutual_exclusion/mutex/copy_fail.cpp +++ b/test/sync/mutual_exclusion/mutex/copy_fail.cpp @@ -19,12 +19,13 @@ // mutex(const mutex&) = delete; #include -#include +#include int main() { boost::mutex m0; boost::mutex m1(m0); + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/mutex/default_pass.cpp b/test/sync/mutual_exclusion/mutex/default_pass.cpp index a911eefcf4..65846c1ae3 100644 --- a/test/sync/mutual_exclusion/mutex/default_pass.cpp +++ b/test/sync/mutual_exclusion/mutex/default_pass.cpp @@ -19,11 +19,12 @@ // mutex(); #include -#include +#include int main() { boost::mutex m0; + (void)m0; return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/mutex/lock_compile_fail.cpp b/test/sync/mutual_exclusion/mutex/lock_compile_fail.cpp index f6bf74b569..acdc35b88d 100644 --- a/test/sync/mutual_exclusion/mutex/lock_compile_fail.cpp +++ b/test/sync/mutual_exclusion/mutex/lock_compile_fail.cpp @@ -8,7 +8,7 @@ // class mutex; #include -#include +#include void fail() { diff --git a/test/sync/mutual_exclusion/mutex/lock_compile_pass.cpp b/test/sync/mutual_exclusion/mutex/lock_compile_pass.cpp index 9da22a59df..53dfabdc39 100644 --- a/test/sync/mutual_exclusion/mutex/lock_compile_pass.cpp +++ b/test/sync/mutual_exclusion/mutex/lock_compile_pass.cpp @@ -8,7 +8,7 @@ // class mutex; #include -#include +#include void pass() { diff --git a/test/sync/mutual_exclusion/mutex/lock_pass.cpp b/test/sync/mutual_exclusion/mutex/lock_pass.cpp index 94818fbad0..0b3fc8f1be 100644 --- a/test/sync/mutual_exclusion/mutex/lock_pass.cpp +++ b/test/sync/mutual_exclusion/mutex/lock_pass.cpp @@ -20,10 +20,10 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -31,8 +31,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -41,35 +41,35 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - m.lock(); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + g_mutex.lock(); + g_t1 = Clock::now(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - m.lock(); - //time_point t1 = Clock::now(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t0 = Clock::now(); + g_mutex.lock(); + //time_point g_t1 = Clock::now(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/mutex/native_handle_pass.cpp b/test/sync/mutual_exclusion/mutex/native_handle_pass.cpp index 489ec375d2..63b6b51f77 100644 --- a/test/sync/mutual_exclusion/mutex/native_handle_pass.cpp +++ b/test/sync/mutual_exclusion/mutex/native_handle_pass.cpp @@ -20,7 +20,7 @@ // native_handle_type native_handle(); #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp b/test/sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp index 05c2016cb8..139b826dee 100644 --- a/test/sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp +++ b/test/sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp @@ -8,7 +8,7 @@ // class mutex; #include -#include +#include void fail() { diff --git a/test/sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp b/test/sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp index e4cec906a9..0b381468a1 100644 --- a/test/sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp +++ b/test/sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp @@ -8,7 +8,7 @@ // class mutex; #include -#include +#include void pass() { diff --git a/test/sync/mutual_exclusion/mutex/try_lock_pass.cpp b/test/sync/mutual_exclusion/mutex/try_lock_pass.cpp index b973c1b239..1372ea26fe 100644 --- a/test/sync/mutual_exclusion/mutex/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/mutex/try_lock_pass.cpp @@ -20,11 +20,11 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::mutex m; +boost::mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #endif const ms max_diff(BOOST_THREAD_TEST_TIME_MS); @@ -41,44 +41,43 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + g_t0 = Clock::now(); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - t1 = Clock::now(); - m.unlock(); + g_t1 = Clock::now(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + //time_point g_t0 = Clock::now(); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - //time_point t1 = Clock::now(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif - } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); @@ -87,5 +86,3 @@ int main() return boost::report_errors(); } - - diff --git a/test/sync/mutual_exclusion/null_mutex/assign_fail.cpp b/test/sync/mutual_exclusion/null_mutex/assign_fail.cpp index e8b440abd0..4d45feff85 100644 --- a/test/sync/mutual_exclusion/null_mutex/assign_fail.cpp +++ b/test/sync/mutual_exclusion/null_mutex/assign_fail.cpp @@ -19,12 +19,14 @@ // null_mutex& operator=(const null_mutex&) = delete; #include -#include +#include int main() { boost::null_mutex m0; - boost::null_mutex m1(m0); + boost::null_mutex m1; + m1 = m0; + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/null_mutex/copy_fail.cpp b/test/sync/mutual_exclusion/null_mutex/copy_fail.cpp index 66668f5e01..0d22b5a1fb 100644 --- a/test/sync/mutual_exclusion/null_mutex/copy_fail.cpp +++ b/test/sync/mutual_exclusion/null_mutex/copy_fail.cpp @@ -19,12 +19,13 @@ // null_mutex(const null_mutex&) = delete; #include -#include +#include int main() { boost::null_mutex m0; boost::null_mutex m1(m0); + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/null_mutex/default_pass.cpp b/test/sync/mutual_exclusion/null_mutex/default_pass.cpp index 343431a9e2..c3a4bd780d 100644 --- a/test/sync/mutual_exclusion/null_mutex/default_pass.cpp +++ b/test/sync/mutual_exclusion/null_mutex/default_pass.cpp @@ -19,11 +19,12 @@ // null_mutex(); #include -#include +#include int main() { boost::null_mutex m0; + (void)m0; return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/null_mutex/lock_pass.cpp b/test/sync/mutual_exclusion/null_mutex/lock_pass.cpp index 3c91e25f61..4efba18e94 100644 --- a/test/sync/mutual_exclusion/null_mutex/lock_pass.cpp +++ b/test/sync/mutual_exclusion/null_mutex/lock_pass.cpp @@ -20,10 +20,10 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::null_mutex m; +boost::null_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -40,20 +40,20 @@ void f() { #if defined BOOST_THREAD_USES_CHRONO time_point t0 = Clock::now(); - m.lock(); + g_mutex.lock(); time_point t1 = Clock::now(); - m.lock(); - m.unlock(); - m.unlock(); + g_mutex.lock(); + g_mutex.unlock(); + g_mutex.unlock(); ns d = t1 - t0 ; BOOST_THREAD_TEST_IT(d, ns(max_diff)); #else //time_point t0 = Clock::now(); - m.lock(); + g_mutex.lock(); //time_point t1 = Clock::now(); - m.lock(); - m.unlock(); - m.unlock(); + g_mutex.lock(); + g_mutex.unlock(); + g_mutex.unlock(); //ns d = t1 - t0 ; //BOOST_TEST(d < max_diff); #endif @@ -61,9 +61,9 @@ void f() int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); - m.unlock(); + g_mutex.unlock(); t.join(); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/null_mutex/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/null_mutex/try_lock_for_pass.cpp index 1f5f5e9fc9..a4fdbaeda5 100644 --- a/test/sync/mutual_exclusion/null_mutex/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/null_mutex/try_lock_for_pass.cpp @@ -21,13 +21,13 @@ #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::null_mutex m; +boost::null_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; @@ -40,11 +40,11 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { time_point t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(250)) == true); + BOOST_TEST(g_mutex.try_lock_for(ms(250)) == true); time_point t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); ns d = t1 - t0 ; BOOST_THREAD_TEST_IT(d, ns(max_diff)); } @@ -52,9 +52,9 @@ void f1() int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/null_mutex/try_lock_pass.cpp b/test/sync/mutual_exclusion/null_mutex/try_lock_pass.cpp index cc51928bbf..0780f54d83 100644 --- a/test/sync/mutual_exclusion/null_mutex/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/null_mutex/try_lock_pass.cpp @@ -20,12 +20,12 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::null_mutex m; +boost::null_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -42,26 +42,26 @@ void f() { #if defined BOOST_THREAD_USES_CHRONO time_point t0 = Clock::now(); - BOOST_TEST(m.try_lock()); + BOOST_TEST(g_mutex.try_lock()); time_point t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); ns d = t1 - t0; BOOST_THREAD_TEST_IT(d, ns(max_diff)); #else - BOOST_TEST(m.try_lock()); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); + BOOST_TEST(g_mutex.try_lock()); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); - m.unlock(); + g_mutex.unlock(); t.join(); return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/null_mutex/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/null_mutex/try_lock_until_pass.cpp index 8a6985165c..fbdf065b2a 100644 --- a/test/sync/mutual_exclusion/null_mutex/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/null_mutex/try_lock_until_pass.cpp @@ -21,12 +21,12 @@ #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::null_mutex m; +boost::null_mutex g_mutex; typedef boost::chrono::steady_clock Clock; typedef Clock::time_point time_point; @@ -39,9 +39,9 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { time_point t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == true); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(250)) == true); time_point t1 = Clock::now(); - m.unlock(); + g_mutex.unlock(); ns d = t1 - t0 ; BOOST_THREAD_TEST_IT(d, ns(max_diff)); } @@ -50,9 +50,9 @@ void f1() int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/once/call_once/call_once_pass.cpp b/test/sync/mutual_exclusion/once/call_once/call_once_pass.cpp index ac7b807695..cb6c26e2c0 100644 --- a/test/sync/mutual_exclusion/once/call_once/call_once_pass.cpp +++ b/test/sync/mutual_exclusion/once/call_once/call_once_pass.cpp @@ -25,7 +25,7 @@ #include #include -#include +#include #ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11 #define BOOST_INIT_ONCE_INIT diff --git a/test/sync/mutual_exclusion/queue_views/single_thread_pass.cpp b/test/sync/mutual_exclusion/queue_views/single_thread_pass.cpp index 05a6282301..f730dae205 100644 --- a/test/sync/mutual_exclusion/queue_views/single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/queue_views/single_thread_pass.cpp @@ -16,7 +16,7 @@ #include #include -#include +#include #include class non_copyable @@ -90,7 +90,7 @@ int main() // empty queue push lvalue/copyable succeeds boost::queue_adaptor > sq; boost::queue_back q(sq); - int i; + int i = 42; q.push(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -141,7 +141,7 @@ int main() // empty queue push lvalue succeeds boost::queue_adaptor > sq; boost::queue_back q(sq); - int i; + int i = 42; q.push(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); diff --git a/test/sync/mutual_exclusion/recursive_mutex/assign_fail.cpp b/test/sync/mutual_exclusion/recursive_mutex/assign_fail.cpp index 041102e911..ab1a1a444b 100644 --- a/test/sync/mutual_exclusion/recursive_mutex/assign_fail.cpp +++ b/test/sync/mutual_exclusion/recursive_mutex/assign_fail.cpp @@ -19,13 +19,14 @@ // recursive_mutex& operator=(const recursive_mutex&) = delete; #include -#include +#include int main() { boost::recursive_mutex m0; - boost::recursive_mutex m1(m0); + boost::recursive_mutex m1; + m1 = m0; + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" - diff --git a/test/sync/mutual_exclusion/recursive_mutex/copy_fail.cpp b/test/sync/mutual_exclusion/recursive_mutex/copy_fail.cpp index 932422d15f..d3db4b966f 100644 --- a/test/sync/mutual_exclusion/recursive_mutex/copy_fail.cpp +++ b/test/sync/mutual_exclusion/recursive_mutex/copy_fail.cpp @@ -19,12 +19,13 @@ // recursive_mutex(const recursive_mutex&) = delete; #include -#include +#include int main() { boost::recursive_mutex m0; boost::recursive_mutex m1(m0); + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/recursive_mutex/default_pass.cpp b/test/sync/mutual_exclusion/recursive_mutex/default_pass.cpp index 6b61997201..497fb63d37 100644 --- a/test/sync/mutual_exclusion/recursive_mutex/default_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_mutex/default_pass.cpp @@ -19,11 +19,12 @@ // recursive_mutex(); #include -#include +#include int main() { boost::recursive_mutex m0; + (void)m0; return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/recursive_mutex/lock_pass.cpp b/test/sync/mutual_exclusion/recursive_mutex/lock_pass.cpp index a5410d25e1..21a5b31549 100644 --- a/test/sync/mutual_exclusion/recursive_mutex/lock_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_mutex/lock_pass.cpp @@ -20,11 +20,11 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::recursive_mutex m; +boost::recursive_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -42,27 +42,27 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - m.lock(); - t1 = Clock::now(); - m.lock(); - m.unlock(); - m.unlock(); + g_t0 = Clock::now(); + g_mutex.lock(); + g_t1 = Clock::now(); + g_mutex.lock(); + g_mutex.unlock(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - m.lock(); - //time_point t1 = Clock::now(); - m.lock(); - m.unlock(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t0 = Clock::now(); + g_mutex.lock(); + //time_point g_t1 = Clock::now(); + g_mutex.lock(); + g_mutex.unlock(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -70,12 +70,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp b/test/sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp index b784f24e5e..0f5e5b923e 100644 --- a/test/sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp @@ -20,7 +20,7 @@ // native_handle_type native_handle(); #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp b/test/sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp index 0f8fe822a9..869556aece 100644 --- a/test/sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp @@ -20,11 +20,11 @@ #include #include -#include +#include #include #include "../../../timming.hpp" -boost::recursive_mutex m; +boost::recursive_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -42,35 +42,35 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); -// BOOST_TEST(!m.try_lock()); -// BOOST_TEST(!m.try_lock()); -// BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + g_t0 = Clock::now(); +// BOOST_TEST(!g_mutex.try_lock()); +// BOOST_TEST(!g_mutex.try_lock()); +// BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); + g_t1 = Clock::now(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + //time_point g_t0 = Clock::now(); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - //time_point t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -78,12 +78,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp index 48b9cc47d0..f3b03bda76 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp @@ -19,12 +19,14 @@ // recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; #include -#include +#include int main() { boost::recursive_timed_mutex m0; - boost::recursive_timed_mutex m1(m0); + boost::recursive_timed_mutex m1; + m1 = m0; + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp index b4e96c7ac9..bf6e75992b 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp @@ -19,12 +19,13 @@ // recursive_timed_mutex(const recursive_timed_mutex&) = delete; #include -#include +#include int main() { boost::recursive_timed_mutex m0; boost::recursive_timed_mutex m1(m0); + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp index 1e75b7b049..88f82ee85a 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp @@ -19,11 +19,12 @@ // recursive_timed_mutex(); #include -#include +#include int main() { boost::recursive_timed_mutex m0; + (void)m0; return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp index bd0646f64a..1e26a1870e 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp @@ -20,11 +20,11 @@ #include #include -#include +#include #include #include "../../../timming.hpp" -boost::recursive_timed_mutex m; +boost::recursive_timed_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -42,27 +42,27 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - m.lock(); - t1 = Clock::now(); - m.lock(); - m.unlock(); - m.unlock(); + g_t0 = Clock::now(); + g_mutex.lock(); + g_t1 = Clock::now(); + g_mutex.lock(); + g_mutex.unlock(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - m.lock(); - //time_point t1 = Clock::now(); - m.lock(); - m.unlock(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t0 = Clock::now(); + g_mutex.lock(); + //time_point g_t1 = Clock::now(); + g_mutex.lock(); + g_mutex.unlock(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -70,12 +70,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp index bcd375e535..d0c4487bb5 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp @@ -20,7 +20,7 @@ // native_handle_type native_handle(); #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp index c7f6d2b0b7..87b16a8521 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp @@ -21,37 +21,37 @@ #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::recursive_timed_mutex m; +boost::recursive_timed_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(750)) == true); - t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_for(ms(750)) == true); + g_t1 = Clock::now(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); } void f2() { time_point t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(250)) == false); + BOOST_TEST(g_mutex.try_lock_for(ms(250)) == false); time_point t1 = Clock::now(); ns d = t1 - t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); @@ -60,26 +60,26 @@ void f2() int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp index 3874d68539..9d9d8527b4 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp @@ -20,10 +20,10 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::recursive_timed_mutex m; +boost::recursive_timed_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -31,8 +31,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -41,35 +41,35 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + g_t0 = Clock::now(); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); + g_t1 = Clock::now(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + //time_point g_t0 = Clock::now(); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - //time_point t1 = Clock::now(); - BOOST_TEST(m.try_lock()); - m.unlock(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + BOOST_TEST(g_mutex.try_lock()); + g_mutex.unlock(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -77,12 +77,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp index 2384672045..c9bb2149b4 100644 --- a/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp @@ -21,54 +21,54 @@ #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::recursive_timed_mutex m; +boost::recursive_timed_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(750)) == true); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(750)) == true); + g_t1 = Clock::now(); + g_mutex.unlock(); } void f2() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(250)) == false); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); @@ -76,10 +76,10 @@ int main() #endif } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/shared_mutex/assign_fail.cpp b/test/sync/mutual_exclusion/shared_mutex/assign_fail.cpp index ee6446d7ee..db5b729182 100644 --- a/test/sync/mutual_exclusion/shared_mutex/assign_fail.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/assign_fail.cpp @@ -19,12 +19,14 @@ // shared_mutex& operator=(const shared_mutex&) = delete; #include -#include +#include int main() { boost::shared_mutex m0; - boost::shared_mutex m1(m0); + boost::shared_mutex m1; + m1 = m0; + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/shared_mutex/copy_fail.cpp b/test/sync/mutual_exclusion/shared_mutex/copy_fail.cpp index 9627f9f668..5d058faf2e 100644 --- a/test/sync/mutual_exclusion/shared_mutex/copy_fail.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/copy_fail.cpp @@ -19,12 +19,13 @@ // shared_mutex(const shared_mutex&) = delete; #include -#include +#include int main() { boost::shared_mutex m0; boost::shared_mutex m1(m0); + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/shared_mutex/default_pass.cpp b/test/sync/mutual_exclusion/shared_mutex/default_pass.cpp index 730c9cafca..2e1ec16c5c 100644 --- a/test/sync/mutual_exclusion/shared_mutex/default_pass.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/default_pass.cpp @@ -19,11 +19,12 @@ // shared_mutex(); #include -#include +#include int main() { boost::shared_mutex m0; + (void)m0; return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp b/test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp index 0b53fb2752..c6e20a1106 100644 --- a/test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp @@ -20,10 +20,10 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -31,8 +31,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -41,23 +41,23 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - m.lock(); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + g_mutex.lock(); + g_t1 = Clock::now(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - m.lock(); - //time_point t1 = Clock::now(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t0 = Clock::now(); + g_mutex.lock(); + //time_point g_t1 = Clock::now(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -65,12 +65,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); @@ -79,4 +79,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp index bc06576ecd..60f4e8c762 100644 --- a/test/sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp @@ -21,52 +21,52 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(750)) == true); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_for(ms(750)) == true); + g_t1 = Clock::now(); + g_mutex.unlock(); } void f2() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(250)) == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_for(ms(250)) == false); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); @@ -74,10 +74,10 @@ int main() #endif } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp b/test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp index 515589a6fb..6d9ecac3de 100644 --- a/test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp @@ -20,10 +20,10 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -31,8 +31,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -41,31 +41,31 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + g_t0 = Clock::now(); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - t1 = Clock::now(); - m.unlock(); + g_t1 = Clock::now(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + //time_point g_t0 = Clock::now(); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - //time_point t1 = Clock::now(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -73,12 +73,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); @@ -87,4 +87,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp index dd8a1a8162..8625be786b 100644 --- a/test/sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp @@ -21,61 +21,61 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::shared_mutex m; +boost::shared_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(750)) == true); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(750)) == true); + g_t1 = Clock::now(); + g_mutex.unlock(); } void f2() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(250)) == false); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/sync_bounded_queue/multi_thread_pass.cpp b/test/sync/mutual_exclusion/sync_bounded_queue/multi_thread_pass.cpp index 9975a995a7..c7e74a912f 100644 --- a/test/sync/mutual_exclusion/sync_bounded_queue/multi_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_bounded_queue/multi_thread_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include struct call_push { diff --git a/test/sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp b/test/sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp index 201e0bc13f..ba868e7f0f 100644 --- a/test/sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp @@ -14,7 +14,7 @@ #include -#include +#include class non_copyable { @@ -103,7 +103,7 @@ int main() { // empty queue push value succeeds boost::sync_bounded_queue q(2); - int i; + int i = 42; q.push(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -162,7 +162,7 @@ int main() // 1-element queue pull succeed boost::sync_bounded_queue q(2); q.push(1); - int i; + int i = -1; q.pull(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -198,7 +198,7 @@ int main() // 1-element queue try_pull succeed boost::sync_bounded_queue q(2); q.push(1); - int i; + int i = -1; BOOST_TEST(q.try_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -210,7 +210,7 @@ int main() // 1-element queue try_pull succeed boost::sync_bounded_queue q(2); q.push(1); - int i; + int i = -1; BOOST_TEST(q.try_pull(boost::no_block, i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -280,7 +280,7 @@ int main() boost::sync_bounded_queue q(2); q.push(1); q.close(); - int i; + int i = -1; q.pull(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -292,7 +292,7 @@ int main() { // empty queue try_pull fails boost::sync_bounded_queue q(2); - int i; + int i = -1; BOOST_TEST( boost::queue_op_status::empty == q.try_pull_front(i)); BOOST_TEST(q.empty()); BOOST_TEST(! q.full()); @@ -334,7 +334,7 @@ int main() { // empty queue push value succeeds boost::sync_bounded_queue q(2); - int i; + int i = 42; q.push_back(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -411,7 +411,7 @@ int main() { // empty queue wait_push value succeeds boost::sync_bounded_queue q(2); - int i; + int i = 42; BOOST_TEST(boost::queue_op_status::success == q.wait_push_back(i)); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -422,7 +422,7 @@ int main() // 1-element queue pull succeed boost::sync_bounded_queue q(2); q.push_back(1); - int i; + int i = -1; q.pull_front(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -458,7 +458,7 @@ int main() // 1-element queue try_pull succeed boost::sync_bounded_queue q(2); q.push_back(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.try_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -470,7 +470,7 @@ int main() // 1-element queue nonblocking_pull_front succeed boost::sync_bounded_queue q(2); q.push_back(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -482,7 +482,7 @@ int main() // 1-element queue wait_pull_front succeed boost::sync_bounded_queue q(2); q.push_back(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -529,7 +529,7 @@ int main() // closed empty queue try_pull_front closed boost::sync_bounded_queue q(2); q.close(); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::closed == q.try_pull_front(i)); BOOST_TEST(q.empty()); BOOST_TEST(! q.full()); @@ -540,7 +540,7 @@ int main() // closed empty queue nonblocking_pull_front closed boost::sync_bounded_queue q(2); q.close(); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::closed == q.nonblocking_pull_front(i)); BOOST_TEST(q.empty()); BOOST_TEST(! q.full()); @@ -552,7 +552,7 @@ int main() boost::sync_bounded_queue q(2); q.push_back(1); q.close(); - int i; + int i = -1; q.pull_front(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -565,7 +565,7 @@ int main() boost::sync_bounded_queue q(2); q.push_back(1); q.close(); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -579,7 +579,7 @@ int main() q.close(); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::closed == q.wait_pull_front(i)); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); @@ -590,11 +590,11 @@ int main() q.close(); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); - int i; + int i = 42; BOOST_TEST(boost::queue_op_status::closed == q.wait_push_back(i)); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); } + return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/sync_deque/multi_thread_pass.cpp b/test/sync/mutual_exclusion/sync_deque/multi_thread_pass.cpp index 703c54f40b..e63fff8c9c 100644 --- a/test/sync/mutual_exclusion/sync_deque/multi_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_deque/multi_thread_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include template struct call_push_back diff --git a/test/sync/mutual_exclusion/sync_deque/single_thread_pass.cpp b/test/sync/mutual_exclusion/sync_deque/single_thread_pass.cpp index 5170bcf614..93545c632b 100644 --- a/test/sync/mutual_exclusion/sync_deque/single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_deque/single_thread_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include class non_copyable { @@ -49,7 +49,7 @@ int main() { // empty queue try_pull fails boost::sync_deque q; - int i; + int i = -1; BOOST_TEST( boost::queue_op_status::empty == q.try_pull_front(i)); BOOST_TEST(q.empty()); BOOST_TEST(! q.full()); @@ -68,7 +68,7 @@ int main() { // empty queue push lvalue/copyable succeeds boost::sync_deque q; - int i; + int i = 42; q.push_back(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -111,7 +111,7 @@ int main() { // empty queue push lvalue succeeds boost::sync_deque q; - int i; + int i = 42; q.push_back(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -204,7 +204,7 @@ int main() // 1-element queue pull_front succeed boost::sync_deque q; q.push_back(1); - int i; + int i = -1; q.pull_front(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -252,7 +252,7 @@ int main() // 1-element queue try_pull_front succeed boost::sync_deque q; q.push_back(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.try_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -277,7 +277,7 @@ int main() // 1-element queue nonblocking_pull_front succeed boost::sync_deque q; q.push_back(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -315,7 +315,7 @@ int main() // 1-element queue wait_pull_front succeed boost::sync_deque q; q.push_back(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -365,7 +365,7 @@ int main() boost::sync_deque q; q.push_back(1); q.close(); - int i; + int i = -1; q.pull_front(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -378,7 +378,7 @@ int main() boost::sync_deque q; q.push_back(1); q.close(); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -392,7 +392,7 @@ int main() q.close(); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::closed == q.wait_pull_front(i)); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); @@ -400,4 +400,3 @@ int main() return boost::report_errors(); } - diff --git a/test/sync/mutual_exclusion/sync_pq/pq_multi_thread_pass.cpp b/test/sync/mutual_exclusion/sync_pq/pq_multi_thread_pass.cpp index 92e183079d..fb91828301 100644 --- a/test/sync/mutual_exclusion/sync_pq/pq_multi_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_pq/pq_multi_thread_pass.cpp @@ -19,6 +19,7 @@ #include #include +#include #include #ifdef BOOST_MSVC diff --git a/test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp b/test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp index b51827731a..ebb612c2a7 100644 --- a/test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include "../../../timming.hpp" using namespace boost::chrono; @@ -55,7 +55,7 @@ void test_pull_for() { sync_pq pq; steady_clock::time_point start = steady_clock::now(); - int val; + int val = -1; boost::queue_op_status st = pq.pull_for(milliseconds(500), val); ns d = steady_clock::now() - start - milliseconds(500); BOOST_THREAD_TEST_IT(d, ns(max_diff)); @@ -66,7 +66,7 @@ void test_pull_until() { sync_pq pq; steady_clock::time_point start = steady_clock::now(); - int val; + int val = -1; boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val); ns d = steady_clock::now() - start - milliseconds(500); BOOST_THREAD_TEST_IT(d, ns(max_diff)); @@ -77,7 +77,7 @@ void test_nonblocking_pull() { sync_pq pq; steady_clock::time_point start = steady_clock::now(); - int val; + int val = -1; boost::queue_op_status st = pq.nonblocking_pull(val); ns d = steady_clock::now() - start; BOOST_THREAD_TEST_IT(d, ns(max_diff)); @@ -89,7 +89,7 @@ void test_pull_for_when_not_empty() sync_pq pq; pq.push(1); steady_clock::time_point start = steady_clock::now(); - int val; + int val = -1; boost::queue_op_status st = pq.pull_for(milliseconds(500), val); ns d = steady_clock::now() - start; BOOST_THREAD_TEST_IT(d, ns(max_diff)); @@ -102,7 +102,7 @@ void test_pull_until_when_not_empty() sync_pq pq; pq.push(1); steady_clock::time_point start = steady_clock::now(); - int val; + int val = -1; boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val); ns d = steady_clock::now() - start; BOOST_THREAD_TEST_IT(d, ns(max_diff)); @@ -274,7 +274,7 @@ int main() // 1-element queue try_pull succeed boost::concurrent::sync_priority_queue q; q.push(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.try_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -301,7 +301,7 @@ int main() // 1-element queue nonblocking_pull succeed boost::concurrent::sync_priority_queue q; q.push(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -341,7 +341,7 @@ int main() // 1-element queue wait_pull succeed boost::concurrent::sync_priority_queue q; q.push(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -406,7 +406,7 @@ int main() boost::concurrent::sync_priority_queue q; q.push(1); q.close(); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -420,7 +420,7 @@ int main() q.close(); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::closed == q.wait_pull(i)); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); diff --git a/test/sync/mutual_exclusion/sync_pq/tq_multi_thread_pass.cpp b/test/sync/mutual_exclusion/sync_pq/tq_multi_thread_pass.cpp index 77656f8b38..b28c3ab213 100644 --- a/test/sync/mutual_exclusion/sync_pq/tq_multi_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_pq/tq_multi_thread_pass.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include "../../../timming.hpp" @@ -42,7 +43,7 @@ void call_pull(sync_tq* q, const steady_clock::time_point start) // pull elements off of the queue (earliest element first) for (int i = cnt - 1; i >= 0; --i) { - int j; + int j = -1; q->pull(j); BOOST_TEST_EQ(i, j); const steady_clock::time_point expected = start + milliseconds(i * 500) + seconds(cnt - i); @@ -56,7 +57,7 @@ void call_pull_until(sync_tq* q, const steady_clock::time_point start) // pull elements off of the queue (earliest element first) for (int i = cnt - 1; i >= 0; --i) { - int j; + int j = -1; q->pull_until(steady_clock::now() + hours(1), j); BOOST_TEST_EQ(i, j); const steady_clock::time_point expected = start + milliseconds(i * 500) + seconds(cnt - i); @@ -70,7 +71,7 @@ void call_pull_for(sync_tq* q, const steady_clock::time_point start) // pull elements off of the queue (earliest element first) for (int i = cnt - 1; i >= 0; --i) { - int j; + int j = -1; q->pull_for(hours(1), j); BOOST_TEST_EQ(i, j); const steady_clock::time_point expected = start + milliseconds(i * 500) + seconds(cnt - i); diff --git a/test/sync/mutual_exclusion/sync_pq/tq_single_thread_pass.cpp b/test/sync/mutual_exclusion/sync_pq/tq_single_thread_pass.cpp index dd4dfc17fb..c95654d662 100644 --- a/test/sync/mutual_exclusion/sync_pq/tq_single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_pq/tq_single_thread_pass.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -49,7 +50,7 @@ void test_all() BOOST_TEST_EQ(val, i); } - int val; + int val = -1; boost::queue_op_status st = pq.nonblocking_pull(val); BOOST_TEST(boost::queue_op_status::empty == st); @@ -86,7 +87,7 @@ void test_all_with_try() BOOST_TEST_EQ(val, i); } - int val; + int val = -1; boost::queue_op_status st = pq.nonblocking_pull(val); BOOST_TEST(st == boost::queue_op_status::empty ); diff --git a/test/sync/mutual_exclusion/sync_queue/multi_thread_pass.cpp b/test/sync/mutual_exclusion/sync_queue/multi_thread_pass.cpp index 556ca68e97..3c26dbc6cc 100644 --- a/test/sync/mutual_exclusion/sync_queue/multi_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_queue/multi_thread_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include template struct call_push diff --git a/test/sync/mutual_exclusion/sync_queue/single_thread_pass.cpp b/test/sync/mutual_exclusion/sync_queue/single_thread_pass.cpp index 8f47ec82ad..382722edb2 100644 --- a/test/sync/mutual_exclusion/sync_queue/single_thread_pass.cpp +++ b/test/sync/mutual_exclusion/sync_queue/single_thread_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include class non_copyable { @@ -82,7 +82,7 @@ int main() { // empty queue push lvalue succeeds boost::sync_queue q; - int i; + int i = 42; q.push(i); BOOST_TEST(! q.empty()); BOOST_TEST(! q.full()); @@ -175,7 +175,7 @@ int main() // 1-element queue pull succeed boost::sync_queue q; q.push(1); - int i; + int i = -1; q.pull(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -223,7 +223,7 @@ int main() // 1-element queue try_pull succeed boost::sync_queue q; q.push(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.try_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -248,7 +248,7 @@ int main() // 1-element queue nonblocking_pull succeed boost::sync_queue q; q.push(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -286,7 +286,7 @@ int main() // 1-element queue wait_pull succeed boost::sync_queue q; q.push(1); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -336,7 +336,7 @@ int main() boost::sync_queue q; q.push(1); q.close(); - int i; + int i = -1; q.pull(i); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -349,7 +349,7 @@ int main() boost::sync_queue q; q.push(1); q.close(); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i)); BOOST_TEST_EQ(i, 1); BOOST_TEST(q.empty()); @@ -363,7 +363,7 @@ int main() q.close(); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); - int i; + int i = -1; BOOST_TEST(boost::queue_op_status::closed == q.wait_pull(i)); BOOST_TEST(q.empty()); BOOST_TEST(q.closed()); diff --git a/test/sync/mutual_exclusion/synchronized_value/call_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/call_pass.cpp index f1ed8be4a9..57045110d9 100644 --- a/test/sync/mutual_exclusion/synchronized_value/call_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/call_pass.cpp @@ -23,7 +23,7 @@ #include -#include +#include struct S { int f() const {return 1;} diff --git a/test/sync/mutual_exclusion/synchronized_value/copy_T_assign_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/copy_T_assign_pass.cpp index 3b43f8f908..21cbbc2291 100644 --- a/test/sync/mutual_exclusion/synchronized_value/copy_T_assign_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/copy_T_assign_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/copy_T_ctor_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/copy_T_ctor_pass.cpp index e395c57aad..f95ae6caa7 100644 --- a/test/sync/mutual_exclusion/synchronized_value/copy_T_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/copy_T_ctor_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/copy_assign_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/copy_assign_pass.cpp index d4e80b0ce9..d282b6e5d7 100644 --- a/test/sync/mutual_exclusion/synchronized_value/copy_assign_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/copy_assign_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/copy_ctor_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/copy_ctor_pass.cpp index 13fcf6d800..b30f66cb08 100644 --- a/test/sync/mutual_exclusion/synchronized_value/copy_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/copy_ctor_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/default_ctor_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/default_ctor_pass.cpp index 7b40956503..3bc44dbe27 100644 --- a/test/sync/mutual_exclusion/synchronized_value/default_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/default_ctor_pass.cpp @@ -13,16 +13,18 @@ #include -#include +#include int main() { { boost::synchronized_value f; + (void)f; } { boost::synchronized_value f; + (void)f; } return boost::report_errors(); diff --git a/test/sync/mutual_exclusion/synchronized_value/indirect_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/indirect_pass.cpp index 09b8e89d21..785c9d4eeb 100644 --- a/test/sync/mutual_exclusion/synchronized_value/indirect_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/indirect_pass.cpp @@ -14,7 +14,7 @@ #include -#include +#include struct S { int f() const {return 1;} diff --git a/test/sync/mutual_exclusion/synchronized_value/move_T_assign_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/move_T_assign_pass.cpp index 146ed2e51d..5ada80582e 100644 --- a/test/sync/mutual_exclusion/synchronized_value/move_T_assign_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/move_T_assign_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/move_T_ctor_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/move_T_ctor_pass.cpp index 564d57da8c..3a7e7960df 100644 --- a/test/sync/mutual_exclusion/synchronized_value/move_T_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/move_T_ctor_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/move_assign_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/move_assign_pass.cpp index 8182163820..d1ccc607ad 100644 --- a/test/sync/mutual_exclusion/synchronized_value/move_assign_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/move_assign_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/move_ctor_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/move_ctor_pass.cpp index 7250e896f9..b0eb259ed3 100644 --- a/test/sync/mutual_exclusion/synchronized_value/move_ctor_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/move_ctor_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/swap_T_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/swap_T_pass.cpp index 801b514d65..0a0ff30a1e 100644 --- a/test/sync/mutual_exclusion/synchronized_value/swap_T_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/swap_T_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/swap_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/swap_pass.cpp index c52069ff3c..22caeadb75 100644 --- a/test/sync/mutual_exclusion/synchronized_value/swap_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/swap_pass.cpp @@ -13,7 +13,7 @@ #include -#include +#include int main() { diff --git a/test/sync/mutual_exclusion/synchronized_value/synchronize_pass.cpp b/test/sync/mutual_exclusion/synchronized_value/synchronize_pass.cpp index af24d79b65..d27c58e654 100644 --- a/test/sync/mutual_exclusion/synchronized_value/synchronize_pass.cpp +++ b/test/sync/mutual_exclusion/synchronized_value/synchronize_pass.cpp @@ -15,7 +15,7 @@ #include -#include +#include struct S { int f() const {return 1;} diff --git a/test/sync/mutual_exclusion/timed_mutex/assign_fail.cpp b/test/sync/mutual_exclusion/timed_mutex/assign_fail.cpp index 49188e1309..b929007375 100644 --- a/test/sync/mutual_exclusion/timed_mutex/assign_fail.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/assign_fail.cpp @@ -19,12 +19,14 @@ // timed_mutex& operator=(const timed_mutex&) = delete; #include -#include +#include int main() { boost::timed_mutex m0; - boost::timed_mutex m1(m0); + boost::timed_mutex m1; + m1 = m0; + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/timed_mutex/copy_fail.cpp b/test/sync/mutual_exclusion/timed_mutex/copy_fail.cpp index ed0a4c9552..cb3daf6398 100644 --- a/test/sync/mutual_exclusion/timed_mutex/copy_fail.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/copy_fail.cpp @@ -19,12 +19,13 @@ // timed_mutex(const timed_mutex&) = delete; #include -#include +#include int main() { boost::timed_mutex m0; boost::timed_mutex m1(m0); + (void)m1; } #include "../../../remove_error_code_unused_warning.hpp" diff --git a/test/sync/mutual_exclusion/timed_mutex/default_pass.cpp b/test/sync/mutual_exclusion/timed_mutex/default_pass.cpp index 6b7c6f2b32..85362cca5f 100644 --- a/test/sync/mutual_exclusion/timed_mutex/default_pass.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/default_pass.cpp @@ -19,11 +19,12 @@ // timed_mutex(); #include -#include +#include int main() { boost::timed_mutex m0; + (void)m0; return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/timed_mutex/lock_pass.cpp b/test/sync/mutual_exclusion/timed_mutex/lock_pass.cpp index 8d2733e1f1..b66c7717b7 100644 --- a/test/sync/mutual_exclusion/timed_mutex/lock_pass.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/lock_pass.cpp @@ -20,10 +20,10 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::timed_mutex m; +boost::timed_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -31,8 +31,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -41,23 +41,23 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - m.lock(); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + g_mutex.lock(); + g_t1 = Clock::now(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - m.lock(); - //time_point t1 = Clock::now(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t0 = Clock::now(); + g_mutex.lock(); + //time_point g_t1 = Clock::now(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -65,12 +65,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp b/test/sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp index b203e5d911..32a4c0d386 100644 --- a/test/sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp @@ -20,7 +20,7 @@ // native_handle_type native_handle(); #include -#include +#include int main() diff --git a/test/sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp b/test/sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp index 94d790e0e5..1b8a334ef9 100644 --- a/test/sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp @@ -21,63 +21,63 @@ #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::timed_mutex m; +boost::timed_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(750)) == true); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_for(ms(750)) == true); + g_t1 = Clock::now(); + g_mutex.unlock(); } void f2() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_for(ms(250)) == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_for(ms(250)) == false); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp b/test/sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp index 96e99e7f74..1f7d73b3f5 100644 --- a/test/sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp @@ -20,11 +20,11 @@ #include #include -#include +#include #include "../../../timming.hpp" -boost::timed_mutex m; +boost::timed_mutex g_mutex; #if defined BOOST_THREAD_USES_CHRONO typedef boost::chrono::high_resolution_clock Clock; @@ -32,8 +32,8 @@ typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; #else #endif @@ -42,31 +42,31 @@ const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f() { #if defined BOOST_THREAD_USES_CHRONO - t0 = Clock::now(); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + g_t0 = Clock::now(); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - t1 = Clock::now(); - m.unlock(); + g_t1 = Clock::now(); + g_mutex.unlock(); #else - //time_point t0 = Clock::now(); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - //BOOST_TEST(!m.try_lock()); - while (!m.try_lock()) + //time_point g_t0 = Clock::now(); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + //BOOST_TEST(!g_mutex.try_lock()); + while (!g_mutex.try_lock()) ; - //time_point t1 = Clock::now(); - m.unlock(); - //ns d = t1 - t0 - ms(250); + //time_point g_t1 = Clock::now(); + g_mutex.unlock(); + //ns d = g_t1 - g_t0 - ms(250); //BOOST_TEST(d < max_diff); #endif } int main() { - m.lock(); + g_mutex.lock(); boost::thread t(f); #if defined BOOST_THREAD_USES_CHRONO time_point t2 = Clock::now(); @@ -74,12 +74,12 @@ int main() time_point t3 = Clock::now(); #else #endif - m.unlock(); + g_mutex.unlock(); t.join(); #if defined BOOST_THREAD_USES_CHRONO ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); diff --git a/test/sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp b/test/sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp index 958a42d03d..e5d9425e43 100644 --- a/test/sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp +++ b/test/sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp @@ -21,63 +21,63 @@ #include #include -#include +#include #include "../../../timming.hpp" #if defined BOOST_THREAD_USES_CHRONO -boost::timed_mutex m; +boost::timed_mutex g_mutex; typedef boost::chrono::high_resolution_clock Clock; typedef Clock::time_point time_point; typedef Clock::duration duration; typedef boost::chrono::milliseconds ms; typedef boost::chrono::nanoseconds ns; -time_point t0; -time_point t1; +time_point g_t0; +time_point g_t1; const ms max_diff(BOOST_THREAD_TEST_TIME_MS); void f1() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(750)) == true); - t1 = Clock::now(); - m.unlock(); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(750)) == true); + g_t1 = Clock::now(); + g_mutex.unlock(); } void f2() { - t0 = Clock::now(); - BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false); - t1 = Clock::now(); - ns d = t1 - t0 - ms(250); + g_t0 = Clock::now(); + BOOST_TEST(g_mutex.try_lock_until(Clock::now() + ms(250)) == false); + g_t1 = Clock::now(); + ns d = g_t1 - g_t0 - ms(250); BOOST_THREAD_TEST_IT(d, ns(max_diff)); } int main() { { - m.lock(); + g_mutex.lock(); boost::thread t(f1); time_point t2 = Clock::now(); boost::this_thread::sleep_for(ms(250)); time_point t3 = Clock::now(); - m.unlock(); + g_mutex.unlock(); t.join(); ns sleep_time = t3 - t2; - ns d_ns = t1 - t0 - sleep_time; + ns d_ns = g_t1 - g_t0 - sleep_time; ms d_ms = boost::chrono::duration_cast(d_ns); // BOOST_TEST_GE(d_ms.count(), 0); BOOST_THREAD_TEST_IT(d_ms, max_diff); BOOST_THREAD_TEST_IT(d_ns, ns(max_diff)); } { - m.lock(); + g_mutex.lock(); boost::thread t(f2); boost::this_thread::sleep_for(ms(750)); - m.unlock(); + g_mutex.unlock(); t.join(); } diff --git a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_bind.cpp b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_bind.cpp index 9ec0dfdfb0..e5e073b608 100644 --- a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_bind.cpp +++ b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_bind.cpp @@ -8,11 +8,12 @@ #define BOOST_THREAD_VERSION 4 -#include // BOOST_TEST +#include // BOOST_TEST #include #include #include +#include class Foo { public: diff --git a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_lambda.cpp b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_lambda.cpp index 8eda53deaa..d0e41423ef 100644 --- a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_lambda.cpp +++ b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_lambda.cpp @@ -14,7 +14,7 @@ #define BOOST_THREAD_VERSION 4 -#include // BOOST_TEST +#include // BOOST_TEST #include // std::cout #include diff --git a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_move.cpp b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_move.cpp index 2c685790d4..cb4cc920b6 100644 --- a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_move.cpp +++ b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_move.cpp @@ -8,7 +8,7 @@ #define BOOST_THREAD_VERSION 4 -#include // BOOST_TEST +#include // BOOST_TEST #include #include diff --git a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_simple.cpp b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_simple.cpp index dc9c44455b..876be358b0 100644 --- a/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_simple.cpp +++ b/test/sync/mutual_exclusion/with_lock_guard/with_lock_guard_simple.cpp @@ -8,7 +8,7 @@ #define BOOST_THREAD_VERSION 4 -#include // BOOST_TEST +#include // BOOST_TEST #include #include diff --git a/test/test_10963.cpp b/test/test_10963.cpp index 1ec8d6cfc9..31b6ca041e 100644 --- a/test/test_10963.cpp +++ b/test/test_10963.cpp @@ -15,6 +15,7 @@ #include #include +#include struct TestCallback { @@ -42,18 +43,18 @@ int main() boost::promise test_promise; boost::future test_future(test_promise.get_future()); auto f1 = test_future.then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f2 = f1.then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); } { boost::basic_thread_pool executor; boost::promise test_promise; boost::future test_future(test_promise.get_future()); auto f1 = test_future.then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f2 = f1.then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); } #endif diff --git a/test/test_10964.cpp b/test/test_10964.cpp index 48ee5cd95f..c1712ac965 100644 --- a/test/test_10964.cpp +++ b/test/test_10964.cpp @@ -16,6 +16,8 @@ #include #include +#include + struct TestCallback { typedef boost::future result_type; @@ -77,7 +79,7 @@ int main() std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; { auto f1 = boost::make_ready_future().then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f1.wait(); } std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; @@ -85,11 +87,11 @@ int main() { auto f1 = boost::make_ready_future().then(TestCallback()); std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; auto f2 = f1.unwrap(); std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; - BOOST_STATIC_ASSERT(std::is_same >::value); + BOOST_STATIC_ASSERT(boost::is_same >::value); std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; f2.wait(); std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; @@ -98,26 +100,26 @@ int main() for (int i=0; i< number_of_tests; i++) { auto f1 = boost::make_ready_future().then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); boost::future f2 = f1.get(); } std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; { auto f1 = boost::make_ready_future().then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f3 = f1.then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f3.wait(); } std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; for (int i=0; i< number_of_tests; i++) { auto f1 = boost::make_ready_future().then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f2 = f1.unwrap(); - BOOST_STATIC_ASSERT(std::is_same >::value); + BOOST_STATIC_ASSERT(boost::is_same >::value); auto f3 = f2.then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f3.wait(); } std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; @@ -137,9 +139,9 @@ int main() for (int i=0; i< number_of_tests; i++) { auto f1 = boost::make_ready_future().then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f3 = f1.then(TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f3.wait(); } std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; @@ -147,9 +149,9 @@ int main() { boost::basic_thread_pool executor; auto f1 = boost::make_ready_future().then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f3 = f1.then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f3.wait(); } #if 1 @@ -160,14 +162,14 @@ int main() boost::basic_thread_pool executor(2); auto f1 = boost::make_ready_future().then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f1.valid()) << std::endl; auto f2 = f1.unwrap(); std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f2.valid()) << std::endl; - BOOST_STATIC_ASSERT(std::is_same >::value); + BOOST_STATIC_ASSERT(boost::is_same >::value); auto f3 = f2.then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f3.wait(); } #endif @@ -177,11 +179,11 @@ int main() boost::basic_thread_pool executor; auto f1 = boost::make_ready_future().then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); auto f2 = f1.unwrap(); - BOOST_STATIC_ASSERT(std::is_same >::value); + BOOST_STATIC_ASSERT(boost::is_same >::value); auto f3 = f2.then(executor, TestCallback()); - BOOST_STATIC_ASSERT(std::is_same > >::value); + BOOST_STATIC_ASSERT(boost::is_same > >::value); f3.wait(); } std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl; diff --git a/test/test_2309.cpp b/test/test_2309.cpp index c3208f97fe..f25dfa5062 100644 --- a/test/test_2309.cpp +++ b/test/test_2309.cpp @@ -11,7 +11,7 @@ #include #include -#include +#include using namespace std; diff --git a/test/test_2741.cpp b/test/test_2741.cpp index 349d7d2ae8..832a720c64 100644 --- a/test/test_2741.cpp +++ b/test/test_2741.cpp @@ -8,9 +8,6 @@ #include #include -#include -#include -#include #include #include @@ -45,7 +42,7 @@ BOOST_AUTO_TEST_CASE(test_native_handle) BOOST_CHECK(!pthread_attr_setstacksize(h, MY_PTHREAD_STACK)); std::size_t res; BOOST_CHECK(!pthread_attr_getstacksize(h, &res)); - BOOST_CHECK(res >= (MY_PTHREAD_STACK)); + BOOST_CHECK(res >= static_cast(MY_PTHREAD_STACK)); #else #error "Boost thread unavailable on this platform" #endif @@ -75,5 +72,3 @@ BOOST_AUTO_TEST_CASE(test_creation_with_attrs) { timed_test(&do_test_creation_with_attrs, 1); } - - diff --git a/test/test_3837.cpp b/test/test_3837.cpp index fd0056f33c..c179ab3113 100644 --- a/test/test_3837.cpp +++ b/test/test_3837.cpp @@ -7,7 +7,8 @@ #include #include #include -#include +#include +#include using namespace boost; using namespace boost::chrono; diff --git a/test/test_4648.cpp b/test/test_4648.cpp index 34fb131afe..2752d59249 100644 --- a/test/test_4648.cpp +++ b/test/test_4648.cpp @@ -6,6 +6,7 @@ #include #include #include +#include class boostThreadLocksTest { diff --git a/test/test_4882.cpp b/test/test_4882.cpp index b1bb725395..1c0fa6ee92 100644 --- a/test/test_4882.cpp +++ b/test/test_4882.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include //#include boost::shared_mutex mutex; diff --git a/test/test_5502.cpp b/test/test_5502.cpp index 455e79eec1..7978997280 100644 --- a/test/test_5502.cpp +++ b/test/test_5502.cpp @@ -12,12 +12,13 @@ int XXX = 20; int YYY = 10; +#include #include #include //#include #include -#include +#include using namespace std; diff --git a/test/test_7328.cpp b/test/test_7328.cpp index 0c0cca03a6..2be6846854 100644 --- a/test/test_7328.cpp +++ b/test/test_7328.cpp @@ -7,7 +7,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/test_8557.cpp b/test/test_8557.cpp index b8efee5a1e..f76a7ec224 100644 --- a/test/test_8557.cpp +++ b/test/test_8557.cpp @@ -10,8 +10,6 @@ #include -#include - #include static void diff --git a/test/test_8943.cpp b/test/test_8943.cpp index 99cf70de19..14be451599 100644 --- a/test/test_8943.cpp +++ b/test/test_8943.cpp @@ -3,7 +3,7 @@ // 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 +#include #if defined(WIN32) #include diff --git a/test/test_8960.cpp b/test/test_8960.cpp index 84cce77e4f..6a7c03a3d0 100644 --- a/test/test_8960.cpp +++ b/test/test_8960.cpp @@ -5,14 +5,12 @@ #include #include - -#include +#include #include #include #include -//#include -#include +#include void do_thread() diff --git a/test/test_9303.cpp b/test/test_9303.cpp index af8be567dd..6bdaa2a145 100644 --- a/test/test_9303.cpp +++ b/test/test_9303.cpp @@ -4,6 +4,7 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #define BOOST_THREAD_VERSION 4 + #include #include #include #include @@ -11,6 +12,7 @@ #include #include #include + #include #include #include #include @@ -86,7 +88,7 @@ #if defined EXAMPLE_3 //! Doesn't compile in C++03. - //! error: variable âboost::packaged_task(std::basic_string&)> exampleâ has initializer but incomplete type + //! error: variable "boost::packaged_task(std::basic_string&)> example" has initializer but incomplete type { boost::packaged_task example(string_with_params); diff --git a/test/test_9856.cpp b/test/test_9856.cpp index b7dcc6e37d..cd8c424342 100644 --- a/test/test_9856.cpp +++ b/test/test_9856.cpp @@ -7,7 +7,7 @@ using namespace boost; int main() { atomic total(0), failures(0); -#pragma omp parallel shared(total, failures) num_threads(1000) +#pragma omp parallel shared(total, failures) num_threads(16) { mutex mtx; condition_variable cond; diff --git a/test/test_barrier.cpp b/test/test_barrier.cpp index 5baf19cd44..1882217398 100644 --- a/test/test_barrier.cpp +++ b/test/test_barrier.cpp @@ -12,7 +12,7 @@ #include #include -#include +#include #include namespace { diff --git a/test/test_barrier_size_fct.cpp b/test/test_barrier_size_fct.cpp index 2671af8485..ff8a7612ff 100644 --- a/test/test_barrier_size_fct.cpp +++ b/test/test_barrier_size_fct.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include namespace { diff --git a/test/test_barrier_void_fct.cpp b/test/test_barrier_void_fct.cpp index 77a65e5814..0572864f88 100644 --- a/test/test_barrier_void_fct.cpp +++ b/test/test_barrier_void_fct.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include namespace { diff --git a/test/test_completion_latch.cpp b/test/test_completion_latch.cpp index bef8836547..252908b1e2 100644 --- a/test/test_completion_latch.cpp +++ b/test/test_completion_latch.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include namespace diff --git a/test/test_condition_notify_all.cpp b/test/test_condition_notify_all.cpp index 17c84d5d50..078604ba2a 100644 --- a/test/test_condition_notify_all.cpp +++ b/test/test_condition_notify_all.cpp @@ -15,6 +15,7 @@ #include "./condition_test_common.hpp" unsigned const number_of_test_threads=5; +unsigned const timeout_grace=1; void do_test_condition_notify_all_wakes_from_wait() { @@ -190,27 +191,23 @@ void do_test_notify_all_following_notify_one_wakes_all_threads() boost::this_thread::sleep(boost::posix_time::milliseconds(200)); multiple_wake_cond.notify_one(); multiple_wake_cond.notify_all(); - boost::this_thread::sleep(boost::posix_time::milliseconds(200)); - - { - boost::unique_lock lk(multiple_wake_mutex); - BOOST_CHECK(multiple_wake_count==3); - } thread1.join(); thread2.join(); thread3.join(); + + { + boost::unique_lock lk(multiple_wake_mutex); + BOOST_CHECK_EQUAL(multiple_wake_count, 3u); + } } BOOST_AUTO_TEST_CASE(test_condition_notify_all) { - timed_test(&do_test_condition_notify_all_wakes_from_wait, timeout_seconds); - timed_test(&do_test_condition_notify_all_wakes_from_wait_with_predicate, timeout_seconds); - timed_test(&do_test_condition_notify_all_wakes_from_timed_wait, timeout_seconds); - timed_test(&do_test_condition_notify_all_wakes_from_timed_wait_with_predicate, timeout_seconds); - timed_test(&do_test_condition_notify_all_wakes_from_relative_timed_wait_with_predicate, timeout_seconds); - timed_test(&do_test_notify_all_following_notify_one_wakes_all_threads, timeout_seconds); + timed_test(&do_test_condition_notify_all_wakes_from_wait, timeout_seconds+timeout_grace); + timed_test(&do_test_condition_notify_all_wakes_from_wait_with_predicate, timeout_seconds+timeout_grace); + timed_test(&do_test_condition_notify_all_wakes_from_timed_wait, timeout_seconds+timeout_grace); + timed_test(&do_test_condition_notify_all_wakes_from_timed_wait_with_predicate, timeout_seconds+timeout_grace); + timed_test(&do_test_condition_notify_all_wakes_from_relative_timed_wait_with_predicate, timeout_seconds+timeout_grace); + timed_test(&do_test_notify_all_following_notify_one_wakes_all_threads, timeout_seconds+timeout_grace); } - - - diff --git a/test/test_condition_notify_one.cpp b/test/test_condition_notify_one.cpp index 00aff62687..42c59fb844 100644 --- a/test/test_condition_notify_one.cpp +++ b/test/test_condition_notify_one.cpp @@ -16,6 +16,8 @@ #include "./util.inl" #include "./condition_test_common.hpp" +unsigned const timeout_grace=1; + void do_test_condition_notify_one_wakes_from_wait() { wait_for_flag data; @@ -125,24 +127,23 @@ void do_test_multiple_notify_one_calls_wakes_multiple_threads() boost::this_thread::sleep(boost::posix_time::milliseconds(200)); multiple_wake_cond.notify_one(); multiple_wake_cond.notify_one(); - boost::this_thread::sleep(boost::posix_time::milliseconds(200)); - - { - boost::unique_lock lk(multiple_wake_mutex); - BOOST_CHECK(multiple_wake_count==3); - } thread1.join(); thread2.join(); thread3.join(); + + { + boost::unique_lock lk(multiple_wake_mutex); + BOOST_CHECK_EQUAL(multiple_wake_count, 3u); + } } BOOST_AUTO_TEST_CASE(test_condition_notify_one) { - timed_test(&do_test_condition_notify_one_wakes_from_wait, timeout_seconds, execution_monitor::use_mutex); - timed_test(&do_test_condition_notify_one_wakes_from_wait_with_predicate, timeout_seconds, execution_monitor::use_mutex); - timed_test(&do_test_condition_notify_one_wakes_from_timed_wait, timeout_seconds, execution_monitor::use_mutex); - timed_test(&do_test_condition_notify_one_wakes_from_timed_wait_with_predicate, timeout_seconds, execution_monitor::use_mutex); - timed_test(&do_test_condition_notify_one_wakes_from_relative_timed_wait_with_predicate, timeout_seconds, execution_monitor::use_mutex); - timed_test(&do_test_multiple_notify_one_calls_wakes_multiple_threads, timeout_seconds, execution_monitor::use_mutex); + timed_test(&do_test_condition_notify_one_wakes_from_wait, timeout_seconds+timeout_grace, execution_monitor::use_mutex); + timed_test(&do_test_condition_notify_one_wakes_from_wait_with_predicate, timeout_seconds+timeout_grace, execution_monitor::use_mutex); + timed_test(&do_test_condition_notify_one_wakes_from_timed_wait, timeout_seconds+timeout_grace, execution_monitor::use_mutex); + timed_test(&do_test_condition_notify_one_wakes_from_timed_wait_with_predicate, timeout_seconds+timeout_grace, execution_monitor::use_mutex); + timed_test(&do_test_condition_notify_one_wakes_from_relative_timed_wait_with_predicate, timeout_seconds+timeout_grace, execution_monitor::use_mutex); + timed_test(&do_test_multiple_notify_one_calls_wakes_multiple_threads, timeout_seconds+timeout_grace, execution_monitor::use_mutex); } diff --git a/test/test_latch.cpp b/test/test_latch.cpp index e2972c9b13..deecd36128 100644 --- a/test/test_latch.cpp +++ b/test/test_latch.cpp @@ -10,7 +10,7 @@ #include #include -#include +#include #include namespace diff --git a/test/test_lock_concept.cpp b/test/test_lock_concept.cpp index ba7de5cd64..ac113ab9d1 100644 --- a/test/test_lock_concept.cpp +++ b/test/test_lock_concept.cpp @@ -7,8 +7,8 @@ #define BOOST_TEST_MODULE Boost.Threads: lock_concept test suite #include -#include #include +#include #include #include #include diff --git a/test/test_ml.cpp b/test/test_ml.cpp index 61b7eff569..d2ca3c038f 100644 --- a/test/test_ml.cpp +++ b/test/test_ml.cpp @@ -6,7 +6,8 @@ #include #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES -#include +#include +#include #include #include #include diff --git a/test/test_mutex.cpp b/test/test_mutex.cpp index e6ac24e271..7927e03297 100644 --- a/test/test_mutex.cpp +++ b/test/test_mutex.cpp @@ -16,6 +16,8 @@ #include #include +#include + #define BOOST_TEST_MODULE Boost.Threads: mutex test suite #include @@ -23,6 +25,8 @@ #define DEFAULT_EXECUTION_MONITOR_TYPE execution_monitor::use_sleep_only #include "./util.inl" +const unsigned int max_wait_attempts = 10u; + template struct test_lock { @@ -46,9 +50,12 @@ struct test_lock boost::xtime xt = delay(0, 100); // Test the lock and the mutex with condition variables. - // No one is going to notify this condition variable. We expect to - // time out. - BOOST_CHECK(!condition.timed_wait(lock, xt)); + // No one is going to notify this condition variable. We expect it to + // usually time out. It may occasionally return true due to a spurious wakeup. + bool wait_result = true; + for (unsigned int attempt = 0u; wait_result && attempt < max_wait_attempts; ++attempt) + wait_result = condition.timed_wait(lock, xt); + BOOST_CHECK(!wait_result); BOOST_CHECK(lock ? true : false); // Test the lock and unlock methods. @@ -86,9 +93,12 @@ struct test_trylock boost::xtime xt = delay(0, 100); // Test the lock and the mutex with condition variables. - // No one is going to notify this condition variable. We expect to - // time out. - BOOST_CHECK(!condition.timed_wait(lock, xt)); + // No one is going to notify this condition variable. We expect it to + // usually time out. It may occasionally return true due to a spurious wakeup. + bool wait_result = true; + for (unsigned int attempt = 0u; wait_result && attempt < max_wait_attempts; ++attempt) + wait_result = condition.timed_wait(lock, xt); + BOOST_CHECK(!wait_result); BOOST_CHECK(lock ? true : false); // Test the lock, unlock and trylock methods. @@ -220,8 +230,8 @@ struct test_timedlock boost::system_time timeout = boost::get_system_time()+boost::posix_time::milliseconds(100); // Test the lock and the mutex with condition variables. - // No one is going to notify this condition variable. We expect to - // time out. + // No one is going to notify this condition variable. We expect it to + // time out. Spurious wakeups should be handled by means of the predicate. BOOST_CHECK(!condition.timed_wait(lock, timeout, fake_predicate)); BOOST_CHECK(lock ? true : false); @@ -336,6 +346,3 @@ BOOST_AUTO_TEST_CASE(test_recursive_timed_mutex) { timed_test(&do_test_recursive_timed_mutex, 3); } - - - diff --git a/test/test_once.cpp b/test/test_once.cpp index 3103f1c237..8d716fd03f 100644 --- a/test/test_once.cpp +++ b/test/test_once.cpp @@ -15,15 +15,15 @@ #include -boost::once_flag flag=BOOST_ONCE_INIT; -int var_to_init=0; -boost::mutex m; +boost::once_flag g_flag=BOOST_ONCE_INIT; +int g_var_to_init=0; +boost::mutex g_mutex; void initialize_variable() { // ensure that if multiple threads get in here, they are serialized, so we can see the effect - boost::unique_lock lock(m); - ++var_to_init; + boost::unique_lock lock(g_mutex); + ++g_var_to_init; } @@ -33,14 +33,14 @@ void call_once_thread() int my_once_value=0; for(unsigned i=0;i lock(m); + boost::unique_lock lock(g_mutex); BOOST_CHECK_EQUAL(my_once_value, 1); } @@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(test_call_once) throw; } - BOOST_CHECK_EQUAL(var_to_init,1); + BOOST_CHECK_EQUAL(g_var_to_init,1); } int var_to_init_with_functor=0; @@ -80,7 +80,7 @@ struct increment_value void operator()() const { - boost::unique_lock lock(m); + boost::unique_lock lock(g_mutex); ++(*value); } }; @@ -99,7 +99,7 @@ void call_once_with_functor() break; } } - boost::unique_lock lock(m); + boost::unique_lock lock(g_mutex); BOOST_CHECK_EQUAL(my_once_value, 1); } @@ -138,7 +138,7 @@ struct throw_before_third_pass void operator()() const { - boost::unique_lock lock(m); + boost::unique_lock lock(g_mutex); ++pass_counter; if(pass_counter<3) { @@ -159,14 +159,14 @@ void call_once_with_exception() } catch(throw_before_third_pass::my_exception) { - boost::unique_lock lock(m); + boost::unique_lock lock(g_mutex); ++exception_counter; } } BOOST_AUTO_TEST_CASE(test_call_once_retried_on_exception) { - BOOST_DETAIL_THREAD_LOG; + BOOST_DETAIL_THREAD_LOG; unsigned const num_threads=20; boost::thread_group group; @@ -188,5 +188,3 @@ BOOST_AUTO_TEST_CASE(test_call_once_retried_on_exception) BOOST_CHECK_EQUAL(throw_before_third_pass::pass_counter,3u); BOOST_CHECK_EQUAL(exception_counter,2u); } - - diff --git a/test/test_scheduler.cpp b/test/test_scheduler.cpp index 5847ff0100..193bd4c5c6 100644 --- a/test/test_scheduler.cpp +++ b/test/test_scheduler.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include diff --git a/test/test_scheduling_adaptor.cpp b/test/test_scheduling_adaptor.cpp index 38c073bda8..4fe11a10ae 100644 --- a/test/test_scheduling_adaptor.cpp +++ b/test/test_scheduling_adaptor.cpp @@ -14,6 +14,7 @@ #define BOOST_THREAD_PROVIDES_EXECUTORS #include +#include #include #include #include diff --git a/test/test_shared_mutex_timed_locks.cpp b/test/test_shared_mutex_timed_locks.cpp index c29c4260c8..a9e240c176 100644 --- a/test/test_shared_mutex_timed_locks.cpp +++ b/test/test_shared_mutex_timed_locks.cpp @@ -63,7 +63,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_shared_succeeds_if_no_lock_held) boost::system_time const start=boost::get_system_time(); boost::system_time const timeout=start+boost::posix_time::milliseconds(500); - boost::posix_time::milliseconds const timeout_resolution(50); bool timed_lock_succeeded=rw_mutex.timed_lock_shared(timeout); BOOST_CHECK(boost::get_system_time() #include #include -#include -#include +#include +#include #define BOOST_TEST_MODULE Boost.Threads: thread test suite @@ -62,7 +62,7 @@ void do_test_creation() BOOST_AUTO_TEST_CASE(test_creation) { - timed_test(&do_test_creation, 1); + timed_test(&do_test_creation, 2); } void do_test_id_comparison() @@ -74,7 +74,7 @@ void do_test_id_comparison() BOOST_AUTO_TEST_CASE(test_id_comparison) { - timed_test(&do_test_id_comparison, 1); + timed_test(&do_test_id_comparison, 2); } void interruption_point_thread(boost::mutex* m,bool* failed) @@ -98,7 +98,7 @@ void do_test_thread_interrupts_at_interruption_point() BOOST_AUTO_TEST_CASE(test_thread_interrupts_at_interruption_point) { - timed_test(&do_test_thread_interrupts_at_interruption_point, 1); + timed_test(&do_test_thread_interrupts_at_interruption_point, 2); } void disabled_interruption_point_thread(boost::mutex* m,bool* failed) @@ -123,7 +123,7 @@ void do_test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point() BOOST_AUTO_TEST_CASE(test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point) { - timed_test(&do_test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point, 1); + timed_test(&do_test_thread_no_interrupt_if_interrupts_disabled_at_interruption_point, 2); } struct non_copyable_functor: @@ -197,6 +197,12 @@ void do_test_timed_join() BOOST_CHECK(xt>now); BOOST_CHECK(joined2); BOOST_CHECK(!thrd.joinable()); + if (thrd.joinable()) + { + // Try to finish the failed test gracefully + thrd.interrupt(); + thrd.join(); + } } BOOST_AUTO_TEST_CASE(test_timed_join) diff --git a/test/test_thread_launching.cpp b/test/test_thread_launching.cpp index 0c74871d3c..5e1c4b1eb6 100644 --- a/test/test_thread_launching.cpp +++ b/test/test_thread_launching.cpp @@ -8,8 +8,8 @@ #include #include -#include -#include +#include +#include #include #include diff --git a/test/test_thread_mf.cpp b/test/test_thread_mf.cpp index 843008fa70..413652dadc 100644 --- a/test/test_thread_mf.cpp +++ b/test/test_thread_mf.cpp @@ -8,7 +8,7 @@ #define BOOST_THREAD_VERSION 3 #include -#include +#include struct X { diff --git a/test/test_time_jumps.cpp b/test/test_time_jumps.cpp index 706bafa479..705bf11d5f 100644 --- a/test/test_time_jumps.cpp +++ b/test/test_time_jumps.cpp @@ -4,18 +4,19 @@ #include #endif -#include "boost/bind/bind.hpp" -#include "boost/chrono.hpp" -#include "boost/chrono/ceil.hpp" -#include "boost/date_time.hpp" -#include "boost/thread/concurrent_queues/sync_priority_queue.hpp" -#include "boost/thread/concurrent_queues/sync_timed_queue.hpp" -#include "boost/thread/future.hpp" -#include "boost/thread/mutex.hpp" -#include "boost/thread/recursive_mutex.hpp" -#include "boost/thread/shared_lock_guard.hpp" -#include "boost/thread/shared_mutex.hpp" -#include "boost/thread/thread.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #ifdef TEST_CPP14_FEATURES diff --git a/test/threads/container/thread_ptr_list_pass.cpp b/test/threads/container/thread_ptr_list_pass.cpp index 76047051f5..3a224ab6fd 100644 --- a/test/threads/container/thread_ptr_list_pass.cpp +++ b/test/threads/container/thread_ptr_list_pass.cpp @@ -10,13 +10,13 @@ #include #include //#include -#include +#include #include -#include +#include -int count = 0; -boost::mutex mutex; +int g_count = 0; +boost::mutex g_mutex; namespace { @@ -33,8 +33,8 @@ void join_all(TC & tc) void increment_count() { - boost::unique_lock lock(mutex); - std::cout << "count = " << ++count << std::endl; + boost::unique_lock lock(g_mutex); + std::cout << "count = " << ++g_count << std::endl; } template @@ -72,7 +72,7 @@ int main() (*it)->join(); } } - count = 0; + g_count = 0; { typedef boost::shared_ptr thread_ptr; //typedef boost::interprocess::shared_ptr, default_delete > thread_ptr; diff --git a/test/threads/container/thread_vector_pass.cpp b/test/threads/container/thread_vector_pass.cpp index 059a77e366..23a5729509 100644 --- a/test/threads/container/thread_vector_pass.cpp +++ b/test/threads/container/thread_vector_pass.cpp @@ -9,11 +9,11 @@ #include #include #include -#include +#include #include -int count = 0; -boost::mutex mutex; +int g_count = 0; +boost::mutex g_mutex; namespace { @@ -40,8 +40,8 @@ void interrupt_all(TC & tc) void increment_count() { - boost::unique_lock lock(mutex); - std::cout << "count = " << ++count << std::endl; + boost::unique_lock lock(g_mutex); + std::cout << "count = " << ++g_count << std::endl; } #if defined BOOST_NO_CXX11_RVALUE_REFERENCES && defined BOOST_THREAD_USES_MOVE @@ -61,7 +61,7 @@ int main() } join_all(threads); } - count = 0; + g_count = 0; { thread_vector threads; threads.reserve(10); @@ -71,7 +71,7 @@ int main() } join_all(threads); } - count = 0; + g_count = 0; { thread_vector threads; threads.reserve(10); @@ -81,7 +81,7 @@ int main() } join_all(threads); } - count = 0; + g_count = 0; { thread_vector threads; threads.reserve(10); diff --git a/test/threads/this_thread/get_id/get_id_pass.cpp b/test/threads/this_thread/get_id/get_id_pass.cpp index f0287cb6ac..2020ba447b 100644 --- a/test/threads/this_thread/get_id/get_id_pass.cpp +++ b/test/threads/this_thread/get_id/get_id_pass.cpp @@ -17,7 +17,7 @@ #include -#include +#include int main() { diff --git a/test/threads/this_thread/sleep_for/sleep_for_pass.cpp b/test/threads/this_thread/sleep_for/sleep_for_pass.cpp index 05c5a790db..09a18f00b2 100644 --- a/test/threads/this_thread/sleep_for/sleep_for_pass.cpp +++ b/test/threads/this_thread/sleep_for/sleep_for_pass.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/threads/this_thread/sleep_until/sleep_until_pass.cpp b/test/threads/this_thread/sleep_until/sleep_until_pass.cpp index 232712eedb..8aed8f6225 100644 --- a/test/threads/this_thread/sleep_until/sleep_until_pass.cpp +++ b/test/threads/this_thread/sleep_until/sleep_until_pass.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO diff --git a/test/threads/thread/assign/copy_fail.cpp b/test/threads/thread/assign/copy_fail.cpp index 5ccac5b315..80c50f59d7 100644 --- a/test/threads/thread/assign/copy_fail.cpp +++ b/test/threads/thread/assign/copy_fail.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/assign/move_pass.cpp b/test/threads/thread/assign/move_pass.cpp index 293c5d838b..a5344f6231 100644 --- a/test/threads/thread/assign/move_pass.cpp +++ b/test/threads/thread/assign/move_pass.cpp @@ -24,7 +24,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/constr/FArgs_pass.cpp b/test/threads/thread/constr/FArgs_pass.cpp index afdc7018fb..722a1cd08f 100644 --- a/test/threads/thread/constr/FArgs_pass.cpp +++ b/test/threads/thread/constr/FArgs_pass.cpp @@ -18,27 +18,52 @@ // template thread(F f, Args... args); #include +#include #include #include #include -#include +#include +#include -unsigned throw_one = 0xFFFF; +thread_local unsigned throw_one = 0xFFFF; +thread_local unsigned operator_new_recursion_level = 0u; + +struct operator_new_recursion_counter +{ + operator_new_recursion_counter() BOOST_NOEXCEPT_OR_NOTHROW + { + ++operator_new_recursion_level; + } + ~operator_new_recursion_counter() BOOST_NOEXCEPT_OR_NOTHROW + { + --operator_new_recursion_level; + } +}; #if defined _GLIBCXX_THROW void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc) -#elif defined BOOST_MSVC -void* operator new(std::size_t s) -#elif __cplusplus > 201402L -void* operator new(std::size_t s) #else -void* operator new(std::size_t s) throw (std::bad_alloc) +void* operator new(std::size_t s) #endif { //std::cout << __FILE__ << ":" << __LINE__ << std::endl; - if (throw_one == 0) throw std::bad_alloc(); - --throw_one; - return std::malloc(s); + // Throwing an exception may recursively call operator new. If we're throwing std::bad_alloc, + // this may cause infinite recursion and a crash. So only throw if we're at the top recursion level. + operator_new_recursion_counter auto_counter; + if (operator_new_recursion_level == 1u) + { + if (throw_one == 0) throw std::bad_alloc(); + --throw_one; + } + void* p = std::malloc(s); + if (!p) + { + if (operator_new_recursion_level == 1u) + throw std::bad_alloc(); + else + std::abort(); + } + return p; } #if defined BOOST_MSVC @@ -51,6 +76,22 @@ void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW std::free(p); } +#if (defined(__cpp_sized_deallocation) && (__cpp_sized_deallocation >= 201309l)) || \ + (BOOST_CXX_VERSION > 201103l && \ + (defined(__GNUC__) && (__GNUC__ >= 5)) || \ + (defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4))) || \ + (defined(BOOST_MSVC) && (_MSC_VER >= 1900)) \ + ) +#if defined BOOST_MSVC +void operator delete(void* p, std::size_t) +#else +void operator delete(void* p, std::size_t) BOOST_NOEXCEPT_OR_NOTHROW +#endif +{ + operator delete(p); +} +#endif + bool f_run = false; void f(int i, double j) @@ -106,7 +147,8 @@ int main() BOOST_TEST(f_run == true); std::cout << __FILE__ << ":" << __LINE__ <<" " << G::n_alive << std::endl; } -#if !defined(BOOST_MSVC) && !defined(__MINGW32__) +// On OpenBSD, the test crashes for unknown reason when operator new throws an exception. +#if !defined(BOOST_MSVC) && !defined(__MINGW32__) && !defined(__OpenBSD__) f_run = false; { std::cout << __FILE__ << ":" << __LINE__ <<" " << G::n_alive << std::endl; diff --git a/test/threads/thread/constr/F_pass.cpp b/test/threads/thread/constr/F_pass.cpp index 7fd2bbc248..e13a87aed1 100644 --- a/test/threads/thread/constr/F_pass.cpp +++ b/test/threads/thread/constr/F_pass.cpp @@ -18,27 +18,52 @@ // template thread(F f, Args... args); #include +#include #include #include #include -#include +#include +#include -unsigned throw_one = 0xFFFF; +thread_local unsigned throw_one = 0xFFFF; +thread_local unsigned operator_new_recursion_level = 0u; + +struct operator_new_recursion_counter +{ + operator_new_recursion_counter() BOOST_NOEXCEPT_OR_NOTHROW + { + ++operator_new_recursion_level; + } + ~operator_new_recursion_counter() BOOST_NOEXCEPT_OR_NOTHROW + { + --operator_new_recursion_level; + } +}; #if defined _GLIBCXX_THROW void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc) -#elif defined BOOST_MSVC -void* operator new(std::size_t s) -#elif __cplusplus > 201402L -void* operator new(std::size_t s) #else -void* operator new(std::size_t s) throw (std::bad_alloc) +void* operator new(std::size_t s) #endif { //std::cout << __FILE__ << ":" << __LINE__ << std::endl; - if (throw_one == 0) throw std::bad_alloc(); - --throw_one; - return std::malloc(s); + // Throwing an exception may recursively call operator new. If we're throwing std::bad_alloc, + // this may cause infinite recursion and a crash. So only throw if we're at the top recursion level. + operator_new_recursion_counter auto_counter; + if (operator_new_recursion_level == 1u) + { + if (throw_one == 0) throw std::bad_alloc(); + --throw_one; + } + void* p = std::malloc(s); + if (!p) + { + if (operator_new_recursion_level == 1u) + throw std::bad_alloc(); + else + std::abort(); + } + return p; } #if defined BOOST_MSVC @@ -51,6 +76,22 @@ void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW std::free(p); } +#if (defined(__cpp_sized_deallocation) && (__cpp_sized_deallocation >= 201309l)) || \ + (BOOST_CXX_VERSION > 201103l && \ + (defined(__GNUC__) && (__GNUC__ >= 5)) || \ + (defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4))) || \ + (defined(BOOST_MSVC) && (_MSC_VER >= 1900)) \ + ) +#if defined BOOST_MSVC +void operator delete(void* p, std::size_t) +#else +void operator delete(void* p, std::size_t) BOOST_NOEXCEPT_OR_NOTHROW +#endif +{ + operator delete(p); +} +#endif + bool f_run = false; void f() @@ -102,7 +143,8 @@ int main() BOOST_TEST(f_run == true); } f_run = false; -#if !defined(BOOST_MSVC) && !defined(__MINGW32__) +// On OpenBSD, the test crashes for unknown reason when operator new throws an exception. +#if !defined(BOOST_MSVC) && !defined(__MINGW32__) && !defined(__OpenBSD__) { try { @@ -125,7 +167,7 @@ int main() BOOST_TEST(G::n_alive == 0); BOOST_TEST(G::op_run); } -#if !defined(BOOST_MSVC) && !defined(__MINGW32__) +#if !defined(BOOST_MSVC) && !defined(__MINGW32__) && !defined(__OpenBSD__) G::op_run = false; { try diff --git a/test/threads/thread/constr/FrvalueArgs_pass.cpp b/test/threads/thread/constr/FrvalueArgs_pass.cpp index e76db70229..0c81e91b3a 100644 --- a/test/threads/thread/constr/FrvalueArgs_pass.cpp +++ b/test/threads/thread/constr/FrvalueArgs_pass.cpp @@ -23,7 +23,7 @@ #include #include #include -#include +#include class MoveOnly { diff --git a/test/threads/thread/constr/Frvalue_pass.cpp b/test/threads/thread/constr/Frvalue_pass.cpp index 38061e0a76..dfddf3aac3 100644 --- a/test/threads/thread/constr/Frvalue_pass.cpp +++ b/test/threads/thread/constr/Frvalue_pass.cpp @@ -23,7 +23,7 @@ #include #include #include -#include +#include #include class MoveOnly diff --git a/test/threads/thread/constr/copy_fail.cpp b/test/threads/thread/constr/copy_fail.cpp index caa72c2d85..6a26853339 100644 --- a/test/threads/thread/constr/copy_fail.cpp +++ b/test/threads/thread/constr/copy_fail.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/constr/default_pass.cpp b/test/threads/thread/constr/default_pass.cpp index cea602d15b..d94bf8ad94 100644 --- a/test/threads/thread/constr/default_pass.cpp +++ b/test/threads/thread/constr/default_pass.cpp @@ -20,7 +20,7 @@ #include #include -#include +#include int main() { diff --git a/test/threads/thread/constr/lambda_pass.cpp b/test/threads/thread/constr/lambda_pass.cpp index 84615bf884..2097826850 100644 --- a/test/threads/thread/constr/lambda_pass.cpp +++ b/test/threads/thread/constr/lambda_pass.cpp @@ -18,28 +18,53 @@ // template thread(Clousure f); #include +#include #include #include #include -#include +#include +#include #if ! defined BOOST_NO_CXX11_LAMBDAS -unsigned throw_one = 0xFFFF; +thread_local unsigned throw_one = 0xFFFF; +thread_local unsigned operator_new_recursion_level = 0u; + +struct operator_new_recursion_counter +{ + operator_new_recursion_counter() BOOST_NOEXCEPT_OR_NOTHROW + { + ++operator_new_recursion_level; + } + ~operator_new_recursion_counter() BOOST_NOEXCEPT_OR_NOTHROW + { + --operator_new_recursion_level; + } +}; #if defined _GLIBCXX_THROW void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc) -#elif defined BOOST_MSVC -void* operator new(std::size_t s) -#elif __cplusplus > 201402L -void* operator new(std::size_t s) #else -void* operator new(std::size_t s) throw (std::bad_alloc) +void* operator new(std::size_t s) #endif { - if (throw_one == 0) throw std::bad_alloc(); - --throw_one; - return std::malloc(s); + // Throwing an exception may recursively call operator new. If we're throwing std::bad_alloc, + // this may cause infinite recursion and a crash. So only throw if we're at the top recursion level. + operator_new_recursion_counter auto_counter; + if (operator_new_recursion_level == 1u) + { + if (throw_one == 0) throw std::bad_alloc(); + --throw_one; + } + void* p = std::malloc(s); + if (!p) + { + if (operator_new_recursion_level == 1u) + throw std::bad_alloc(); + else + std::abort(); + } + return p; } #if defined BOOST_MSVC @@ -51,6 +76,22 @@ void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW std::free(p); } +#if (defined(__cpp_sized_deallocation) && (__cpp_sized_deallocation >= 201309l)) || \ + (BOOST_CXX_VERSION > 201103l && \ + (defined(__GNUC__) && (__GNUC__ >= 5)) || \ + (defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4))) || \ + (defined(BOOST_MSVC) && (_MSC_VER >= 1900)) \ + ) +#if defined BOOST_MSVC +void operator delete(void* p, std::size_t) +#else +void operator delete(void* p, std::size_t) BOOST_NOEXCEPT_OR_NOTHROW +#endif +{ + operator delete(p); +} +#endif + bool f_run = false; int main() @@ -61,7 +102,8 @@ int main() t.join(); BOOST_TEST(f_run == true); } -#if !defined(BOOST_MSVC) && !defined(__MINGW32__) +// On OpenBSD, the test crashes for unknown reason when operator new throws an exception. +#if !defined(BOOST_MSVC) && !defined(__MINGW32__) && !defined(__OpenBSD__) { f_run = false; try diff --git a/test/threads/thread/constr/move_pass.cpp b/test/threads/thread/constr/move_pass.cpp index 66f9d75464..0caca29acc 100644 --- a/test/threads/thread/constr/move_pass.cpp +++ b/test/threads/thread/constr/move_pass.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/destr/dtor_pass.cpp b/test/threads/thread/destr/dtor_pass.cpp index ea0e6bac42..4c4eebd297 100644 --- a/test/threads/thread/destr/dtor_pass.cpp +++ b/test/threads/thread/destr/dtor_pass.cpp @@ -22,7 +22,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/id/hash_pass.cpp b/test/threads/thread/id/hash_pass.cpp index 6ce52c97a2..645f903359 100644 --- a/test/threads/thread/id/hash_pass.cpp +++ b/test/threads/thread/id/hash_pass.cpp @@ -24,7 +24,7 @@ #include -#include +#include int main() { diff --git a/test/threads/thread/members/detach_pass.cpp b/test/threads/thread/members/detach_pass.cpp index 927175338b..59ce8a62f8 100644 --- a/test/threads/thread/members/detach_pass.cpp +++ b/test/threads/thread/members/detach_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/members/get_id_pass.cpp b/test/threads/thread/members/get_id_pass.cpp index dcaa7090bc..459495030f 100644 --- a/test/threads/thread/members/get_id_pass.cpp +++ b/test/threads/thread/members/get_id_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/members/join_pass.cpp b/test/threads/thread/members/join_pass.cpp index f2d42b72bc..322f48156c 100644 --- a/test/threads/thread/members/join_pass.cpp +++ b/test/threads/thread/members/join_pass.cpp @@ -24,7 +24,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/members/joinable_pass.cpp b/test/threads/thread/members/joinable_pass.cpp index dcf09d1f83..d0e4de9154 100644 --- a/test/threads/thread/members/joinable_pass.cpp +++ b/test/threads/thread/members/joinable_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/members/native_handle_pass.cpp b/test/threads/thread/members/native_handle_pass.cpp index 01115da051..7f4fbcbd44 100644 --- a/test/threads/thread/members/native_handle_pass.cpp +++ b/test/threads/thread/members/native_handle_pass.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/members/swap_pass.cpp b/test/threads/thread/members/swap_pass.cpp index 16af2d1b8e..427306aa07 100644 --- a/test/threads/thread/members/swap_pass.cpp +++ b/test/threads/thread/members/swap_pass.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include class G { diff --git a/test/threads/thread/members/try_join_for_pass.cpp b/test/threads/thread/members/try_join_for_pass.cpp index 5215d18d6a..8e3295830a 100644 --- a/test/threads/thread/members/try_join_for_pass.cpp +++ b/test/threads/thread/members/try_join_for_pass.cpp @@ -22,25 +22,34 @@ #include #include #include +#include #include #include #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO class G { + boost::barrier* bar_; int alive_; public: static bool op_run; G() : + bar_(nullptr), + alive_(1) + { + } + explicit G(boost::barrier& bar) : + bar_(&bar), alive_(1) { } G(const G& g) : + bar_(g.bar_), alive_(g.alive_) { } @@ -52,6 +61,8 @@ class G void operator()() { BOOST_TEST(alive_ == 1); + if (bar_) + bar_->count_down_and_wait(); op_run = true; } }; @@ -86,9 +97,11 @@ void th_250_ms() int main() { { - boost::thread t0( (G())); + boost::barrier bar(2u); + boost::thread t0( (G(bar))); BOOST_TEST(t0.joinable()); - BOOST_TEST(t0.try_join_for(boost::chrono::milliseconds(250))); + bar.count_down_and_wait(); + BOOST_TEST(t0.try_join_for(boost::chrono::milliseconds(500))); BOOST_TEST(!t0.joinable()); } { @@ -123,8 +136,10 @@ int main() } } { - boost::thread t0( (G())); + boost::barrier bar(2u); + boost::thread t0( (G(bar))); BOOST_TEST(t0.joinable()); + bar.count_down_and_wait(); t0.join(); try { @@ -138,9 +153,11 @@ int main() } { - boost::thread t0( (G())); + boost::barrier bar(2u); + boost::thread t0( (G(bar))); BOOST_TEST(t0.joinable()); - t0.try_join_for(boost::chrono::milliseconds(250)); + bar.count_down_and_wait(); + t0.try_join_for(boost::chrono::milliseconds(500)); try { t0.join(); diff --git a/test/threads/thread/members/try_join_until_pass.cpp b/test/threads/thread/members/try_join_until_pass.cpp index 749ff5b064..7473aac07b 100644 --- a/test/threads/thread/members/try_join_until_pass.cpp +++ b/test/threads/thread/members/try_join_until_pass.cpp @@ -22,25 +22,34 @@ #include #include #include +#include #include #include #include #include -#include +#include #if defined BOOST_THREAD_USES_CHRONO class G { + boost::barrier* bar_; int alive_; public: static bool op_run; G() : + bar_(nullptr), + alive_(1) + { + } + explicit G(boost::barrier& bar) : + bar_(&bar), alive_(1) { } G(const G& g) : + bar_(g.bar_), alive_(g.alive_) { } @@ -52,6 +61,8 @@ class G void operator()() { BOOST_TEST(alive_ == 1); + if (bar_) + bar_->count_down_and_wait(); op_run = true; } }; @@ -87,9 +98,11 @@ void th_250_ms() int main() { { - boost::thread t0( (G())); + boost::barrier bar(2u); + boost::thread t0( (G(bar))); BOOST_TEST(t0.joinable()); - t0.try_join_until(boost::chrono::steady_clock::now()+boost::chrono::milliseconds(250)); + bar.count_down_and_wait(); + t0.try_join_until(boost::chrono::steady_clock::now()+boost::chrono::milliseconds(500)); BOOST_TEST(!t0.joinable()); } { @@ -124,8 +137,10 @@ int main() } } { - boost::thread t0( (G())); + boost::barrier bar(2u); + boost::thread t0( (G(bar))); BOOST_TEST(t0.joinable()); + bar.count_down_and_wait(); t0.join(); try { @@ -139,9 +154,11 @@ int main() } { - boost::thread t0( (G())); + boost::barrier bar(2u); + boost::thread t0( (G(bar))); BOOST_TEST(t0.joinable()); - t0.try_join_until(boost::chrono::steady_clock::now()+boost::chrono::milliseconds(250)); + bar.count_down_and_wait(); + t0.try_join_until(boost::chrono::steady_clock::now()+boost::chrono::milliseconds(500)); try { t0.join(); diff --git a/test/threads/thread/non_members/swap_pass.cpp b/test/threads/thread/non_members/swap_pass.cpp index eb6faf1579..5726ab2cc5 100644 --- a/test/threads/thread/non_members/swap_pass.cpp +++ b/test/threads/thread/non_members/swap_pass.cpp @@ -19,7 +19,7 @@ #include #include #include -#include +#include class G { diff --git a/test/threads/thread/static/hardware_concurrency_pass.cpp b/test/threads/thread/static/hardware_concurrency_pass.cpp index 2a2a227ed9..5dcd5cd696 100644 --- a/test/threads/thread/static/hardware_concurrency_pass.cpp +++ b/test/threads/thread/static/hardware_concurrency_pass.cpp @@ -18,7 +18,7 @@ // static unsigned hardware_concurrency(); #include -#include +#include int main() { diff --git a/test/timming.hpp b/test/timming.hpp index 09c51ff8ea..b83642da2c 100644 --- a/test/timming.hpp +++ b/test/timming.hpp @@ -7,14 +7,14 @@ #define BOOST_THREAD_TEST_TIMMING_HPP #include -#include +#include #if ! defined BOOST_THREAD_TEST_TIME_MS #ifdef __linux__ #define BOOST_THREAD_TEST_TIME_MS 75 #else // Windows, Cygwin, macOS all need this -#define BOOST_THREAD_TEST_TIME_MS 400 +#define BOOST_THREAD_TEST_TIME_MS 700 #endif #endif