diff --git a/.drone.star b/.drone.star new file mode 100644 index 0000000..21b4bfb --- /dev/null +++ b/.drone.star @@ -0,0 +1,43 @@ +# Use, modification, and distribution are +# subject to the Boost Software License, Version 1.0. (See accompanying +# file LICENSE.txt) +# +# Copyright Rene Rivera 2020. + +# For Drone CI we use the Starlark scripting language to reduce duplication. +# As the yaml syntax for Drone CI is rather limited. +# +# + +globalenv={'B2_CI_VERSION': '1', 'B2_VARIANT': 'release'} +linuxglobalimage="cppalliance/droneubuntu1604:1" +windowsglobalimage="cppalliance/dronevs2019" + +def main(ctx): + return [ + linux_cxx("COMMENT=codecov.io B2_CXXSTD=03,11 B2_TOOLSET Job 0", "g++-8", packages="g++-8 locales", buildtype="fc4716b68c-0fcaf592f9", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'codecov.io', 'B2_CXXSTD': '03,11', 'B2_TOOLSET': 'gcc-8', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv), + linux_cxx("COMMENT=asan B2_VARIANT=debug B2_TOOLSET=gcc- Job 1", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'asan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '03,11,14', 'B2_ASAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_EXTRA_PRIVILEGED': 'True', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv, privileged=True), + linux_cxx("COMMENT=tsan B2_VARIANT=debug B2_TOOLSET=gcc- Job 2", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'tsan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '03,11,14', 'B2_TSAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv), + linux_cxx("COMMENT=ubsan B2_VARIANT=debug B2_TOOLSET=gcc Job 3", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'ubsan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '03,11,14', 'B2_UBSAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'B2_LINKFLAGS': '-fuse-ld=gold', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv), + linux_cxx("COMMENT=valgrind B2_TOOLSET=clang-6.0 B2_CXXS Job 4", "clang++-6.0", packages="clang-6.0 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="6.0", buildtype="fc4716b68c-db180b7bd2", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'valgrind', 'B2_TOOLSET': 'clang-6.0', 'B2_CXXSTD': '03,11,14', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'B2_VARIANT': 'debug', 'B2_TESTFLAGS': 'testing.launcher=valgrind', 'VALGRIND_OPTS': '--error-exitcode=1', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-4.8 B2_CXXSTD=03,11 Job 5", "g++-4.8", packages="g++-4.8 locales", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'B2_TOOLSET': 'gcc-4.8', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-4.9 B2_CXXSTD=03,11 Job 6", "g++-4.9", packages="g++-4.9 locales", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'B2_TOOLSET': 'gcc-4.9', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-5 B2_CXXSTD=03,11 Job 7", "g++-5", packages="g++-5 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-5', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-6 B2_CXXSTD=11,14 Job 8", "g++-6", packages="g++-6 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-6', 'B2_CXXSTD': '11,14', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-7 B2_CXXSTD=14,17 Job 9", "g++-7", packages="g++-7 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-7', 'B2_CXXSTD': '14,17', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-8 B2_CXXSTD=17,2a Job 10", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=gcc-9 B2_CXXSTD=17,2a Job 11", "g++-9", packages="g++-9 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-9', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-3.8 B2_CXXSTD=03,11 Job 12", "clang++-3.8 locales", packages="clang-3.8 locales", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'B2_TOOLSET': 'clang-3.8', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-4.0 B2_CXXSTD=11,14 Job 13", "clang++-4.0 locales", packages="clang-4.0 libstdc++-6-dev locales", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-4.0', 'B2_CXXSTD': '11,14', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-5.0 B2_CXXSTD=11,14 Job 14", "clang++-5.0 locales", packages="clang-5.0 libstdc++-7-dev locales", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-5.0', 'B2_CXXSTD': '11,14', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-6.0 B2_CXXSTD=14,17 Job 15", "clang++-6.0 locales", packages="clang-6.0 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-6.0', 'B2_CXXSTD': '14,17', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-7 B2_CXXSTD=17,2a Job 16", "clang++-7 locales", packages="clang-7 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-7', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': '1574bddb75'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-8 B2_CXXSTD=17,2a Job 17", "clang++-8 locales", packages="clang-8 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-8', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': '0716d9708d'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-9 B2_CXXSTD=03,11,14,17,2a Job 18", "clang++-9 locales", packages="clang-8 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-9', 'B2_CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '9e6a55b6b4'}, globalenv=globalenv), + linux_cxx("B2_TOOLSET=clang-6.0 B2_CXXSTD=03,11,14 B2_ST Job 19", "clang++-6.0 locales", packages="clang-6.0 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-6.0', 'B2_CXXSTD': '03,11,14', 'B2_STDLIB': 'libc++', 'DRONE_JOB_UUID': 'b3f0c7f6bb'}, globalenv=globalenv), + osx_cxx("B2_TOOLSET=clang B2_CXXSTD=03,11,17 Job 20", "g++", packages="", buildtype="boost", buildscript="drone", environment={'B2_TOOLSET': 'clang', 'B2_CXXSTD': '03,11,17', 'DRONE_JOB_UUID': '91032ad7bb'}, globalenv=globalenv), + linux_cxx("COMMENT=Coverity Scan B2_TOOLSET=clang Job 21", "g++", packages="locales", buildtype="fc4716b68c-cce9827eb5", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'Coverity Scan', 'B2_TOOLSET': 'clang', 'DRONE_JOB_UUID': '472b07b9fc'}, globalenv=globalenv), + ] + +# from https://github.com/boostorg/boost-ci +load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx") diff --git a/.drone/drone.sh b/.drone/drone.sh new file mode 100755 index 0000000..4ae5d7c --- /dev/null +++ b/.drone/drone.sh @@ -0,0 +1,120 @@ +#!/bin/bash + +# Copyright 2020 Rene Rivera, Sam Darwin +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt) + +set -e +export TRAVIS_BUILD_DIR=$(pwd) +export DRONE_BUILD_DIR=$(pwd) +export TRAVIS_BRANCH=$DRONE_BRANCH +export TRAVIS_EVENT_TYPE=$DRONE_BUILD_EVENT +export VCS_COMMIT_ID=$DRONE_COMMIT +export GIT_COMMIT=$DRONE_COMMIT +export REPO_NAME=$DRONE_REPO +export USER=$(whoami) +export CC=${CC:-gcc} +export PATH=~/.local/bin:/usr/local/bin:$PATH + +if [[ ${TRAVIS_OS_NAME} =~ [Ll]inux ]]; then + echo Installing locales for ${TRAVIS_OS_NAME} ... + sudo /usr/sbin/locale-gen fr_FR + sudo /usr/sbin/locale-gen en_GB + sudo locale -a + echo ...done with locales +fi + +if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then + +echo '==================================> INSTALL' + +git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned +cp -prf boost-ci-cloned/ci . +rm -rf boost-ci-cloned + +if [ "$TRAVIS_OS_NAME" == "osx" ]; then + unset -f cd +fi + +export SELF=`basename $REPO_NAME` +export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH" +export BOOST_CI_SRC_FOLDER=$(pwd) + +. ./ci/common_install.sh + +echo '==================================> SCRIPT' + +$BOOST_ROOT/libs/$SELF/ci/travis/build.sh + +elif [ "$DRONE_JOB_BUILDTYPE" == "fc4716b68c-0fcaf592f9" ]; then + +echo '==================================> INSTALL' + +git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned +cp -prf boost-ci-cloned/ci . +rm -rf boost-ci-cloned + +if [ "$TRAVIS_OS_NAME" == "osx" ]; then + unset -f cd +fi + +export SELF=`basename $REPO_NAME` +export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH" +export BOOST_CI_SRC_FOLDER=$(pwd) + +. ./ci/common_install.sh + +echo '==================================> SCRIPT' + +cd $BOOST_ROOT/libs/$SELF +ci/travis/codecov.sh + +elif [ "$DRONE_JOB_BUILDTYPE" == "fc4716b68c-db180b7bd2" ]; then + +echo '==================================> INSTALL' + +git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned +cp -prf boost-ci-cloned/ci . +rm -rf boost-ci-cloned + +if [ "$TRAVIS_OS_NAME" == "osx" ]; then + unset -f cd +fi + +export SELF=`basename $REPO_NAME` +export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH" +export BOOST_CI_SRC_FOLDER=$(pwd) + +. ./ci/common_install.sh + +echo '==================================> SCRIPT' + +cd $BOOST_ROOT/libs/$SELF +ci/travis/valgrind.sh + +elif [ "$DRONE_JOB_BUILDTYPE" == "fc4716b68c-cce9827eb5" ]; then + +echo '==================================> INSTALL' + +git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned +cp -prf boost-ci-cloned/ci . +rm -rf boost-ci-cloned + +if [ "$TRAVIS_OS_NAME" == "osx" ]; then + unset -f cd +fi + +export SELF=`basename $REPO_NAME` +export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH" +export BOOST_CI_SRC_FOLDER=$(pwd) + +. ./ci/common_install.sh + +echo '==================================> SCRIPT' + +if [ -n "${COVERITY_SCAN_NOTIFICATION_EMAIL}" -a \( "$TRAVIS_BRANCH" = "develop" -o "$TRAVIS_BRANCH" = "master" \) -a \( "$DRONE_BUILD_EVENT" = "push" -o "$DRONE_BUILD_EVENT" = "cron" \) ] ; then + cd $BOOST_ROOT/libs/$SELF + ci/travis/coverity.sh +fi + +fi diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..156cc4f --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,248 @@ +name: CI + +on: + pull_request: + push: + branches: + - master + - develop + - feature/** + +env: + UBSAN_OPTIONS: print_stacktrace=1 + +jobs: + posix: + strategy: + fail-fast: false + matrix: + include: + - toolset: gcc-4.7 + cxxstd: "03,11" + os: ubuntu-16.04 + install: g++-4.7 + - toolset: gcc-4.8 + cxxstd: "03,11" + os: ubuntu-16.04 + install: g++-4.8 + - toolset: gcc-4.9 + cxxstd: "03,11" + os: ubuntu-16.04 + install: g++-4.9 + - toolset: gcc-5 + cxxstd: "03,11,14,1z" + os: ubuntu-16.04 + - toolset: gcc-6 + cxxstd: "03,11,14,1z" + os: ubuntu-16.04 + install: g++-6 + - toolset: gcc-7 + cxxstd: "03,11,14,17" + os: ubuntu-18.04 + - toolset: gcc-8 + cxxstd: "03,11,14,17,2a" + os: ubuntu-18.04 + - toolset: gcc-9 + cxxstd: "03,11,14,17,2a" + os: ubuntu-18.04 + - toolset: gcc-10 + cxxstd: "03,11,14,17,2a" + os: ubuntu-18.04 + - toolset: clang + compiler: clang++-3.5 + cxxstd: "03,11,14" + os: ubuntu-16.04 + install: clang-3.5 + - toolset: clang + compiler: clang++-3.6 + cxxstd: "03,11,14" + os: ubuntu-16.04 + install: clang-3.6 + - toolset: clang + compiler: clang++-3.7 + cxxstd: "03,11,14" + os: ubuntu-16.04 + install: clang-3.7 + - toolset: clang + compiler: clang++-3.8 + cxxstd: "03,11,14" + os: ubuntu-16.04 + install: clang-3.8 + - toolset: clang + compiler: clang++-3.9 + cxxstd: "03,11,14" + os: ubuntu-16.04 + install: clang-3.9 + - toolset: clang + compiler: clang++-4.0 + cxxstd: "03,11,14" + os: ubuntu-16.04 + install: clang-4.0 + - toolset: clang + compiler: clang++-5.0 + cxxstd: "03,11,14,1z" + os: ubuntu-16.04 + install: clang-5.0 + - toolset: clang + compiler: clang++-6.0 + cxxstd: "03,11,14,17" + os: ubuntu-18.04 + - toolset: clang + compiler: clang++-7 + cxxstd: "03,11,14,17" + os: ubuntu-18.04 + install: clang-7 + - toolset: clang + compiler: clang++-8 + cxxstd: "03,11,14,17,2a" + os: ubuntu-20.04 + - toolset: clang + compiler: clang++-9 + cxxstd: "03,11,14,17,2a" + os: ubuntu-20.04 + - toolset: clang + compiler: clang++-10 + cxxstd: "03,11,14,17,2a" + os: ubuntu-20.04 + - toolset: clang + cxxstd: "03,11,14,17,2a" + os: macos-10.15 + + runs-on: ${{matrix.os}} + + steps: + - uses: actions/checkout@v2 + + - name: Install packages + if: matrix.install + run: sudo apt install ${{matrix.install}} + + - name: Setup Boost + run: | + if [[ $(uname) =~ [Ll]inux ]]; then + echo Installing locales for ${TRAVIS_OS_NAME} ... + sudo /usr/sbin/locale-gen fr_FR + sudo /usr/sbin/locale-gen en_GB + sudo locale -a + echo ...done with locales + fi + 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 + python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY + ./bootstrap.sh + ./b2 -d0 headers + + - name: Create user-config.jam + if: matrix.compiler + run: | + echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam + + - name: Run tests + run: | + cd ../boost-root + toolsets=$(sed 's/,/ /g' <<<"${{matrix.toolset}}") + standards=$(sed 's/,/ /g' <<<"${{matrix.cxxstd}}") + variants="debug release" + err=0 + for toolset in ${toolsets} ; do + for standard in ${standards} ; do + for variant in ${variants} ; do + if [[ err -ne 0 ]] ; then + echo "skipping: ${toolset} ${standard} ${variant}" + else + echo "running: ${toolset} ${standard} ${variant}" + ./b2 -j3 libs/$LIBRARY/test toolset=${toolset} cxxstd=${standard} variant=${variant} + err=$? + fi + done + done + done + [[ $err -ne 0 ]] && false || true + + windows: + strategy: + fail-fast: false + matrix: + include: + - toolset: msvc-14.1 + cxxstd: "14,17,latest" + addrmd: 32,64 + os: windows-2016 + cxxflags: "" + - toolset: msvc-14.2 + cxxstd: "14,17,latest" + addrmd: 32,64 + os: windows-2019 + cxxflags: "" + - toolset: gcc + cxxstd: "03,11,14,17,2a" + addrmd: 64 + os: windows-2019 + cxxflags: "cxxflags=-Wa,-mbig-obj" + + runs-on: ${{matrix.os}} + + steps: + - uses: actions/checkout@v2 + + - name: Setup Boost + shell: cmd + run: | + echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY% + for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi + echo LIBRARY: %LIBRARY% + echo LIBRARY=%LIBRARY%>>%GITHUB_ENV% + echo GITHUB_BASE_REF: %GITHUB_BASE_REF% + echo GITHUB_REF: %GITHUB_REF% + if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF% + set BOOST_BRANCH=develop + for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master + echo BOOST_BRANCH: %BOOST_BRANCH% + cd .. + git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root + cd boost-root + xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\ + git submodule update --init tools/boostdep + python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY% + cmd /c bootstrap + b2 -d0 headers + + - name: Run tests + shell: bash + run: | + cd ../boost-root + toolsets=$(sed 's/,/ /g' <<<"${{matrix.toolset}}") + standards=$(sed 's/,/ /g' <<<"${{matrix.cxxstd}}") + address_models=$(sed 's/,/ /g' <<<"${{matrix.addrmd}}") + variants="debug release" + err=0 + for toolset in ${toolsets} ; do + for standard in ${standards} ; do + for address_model in ${address_models} ; do + for variant in ${variants} ; do + if [[ err -ne 0 ]] ; then + echo "skipping: ${toolset} ${standard} ${address_model} ${variant}" + else + echo "running: ${toolset} ${standard} ${address_model} ${variant}" + ./b2 -j3 ${{matrix.cxxflags}} libs/$LIBRARY/test toolset=${toolset} cxxstd=${standard} address-model=${address_model} variant=${variant} + err=$? + fi + done + done + done + done + [[ $err -ne 0 ]] && false || true diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..22516cf --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,100 @@ +# +# Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) +# Copyright (c) 2021 Richard Hodges (hodges.r@gmail.com) +# +# 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) +# +# Official repository: https://github.com/boostorg/property_tree +# + +cmake_minimum_required(VERSION 3.5...3.19) + +set(BOOST_PROPERTY_TREE_VERSION ${BOOST_SUPERPROJECT_VERSION}) + +project(boost_property_tree VERSION "${BOOST_PROPERTY_TREE_VERSION}" LANGUAGES CXX) + +option(BOOST_PROPERTY_TREE_BUILD_TESTS "Build boost::property_tree tests" ${BUILD_TESTING}) +option(BOOST_PROPERTY_TREE_BUILD_EXAMPLES "Build boost::property_tree examples" ${BOOST_PROPERTY_TREE_BUILD_TESTS}) + +file(GLOB_RECURSE BOOST_PROPERTY_TREE_HEADERS $<$:CONFIGURE_DEPENDS> + include/boost/*.hpp + include/boost/*.ipp + include/boost/*.natvis +) + +set(BOOST_PROPERTY_TREE_SOURCES +) + +set_property(GLOBAL PROPERTY USE_FOLDERS ON) + +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/include/boost PREFIX "" FILES ${BOOST_PROPERTY_TREE_HEADERS}) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/src PREFIX "" FILES ${BOOST_PROPERTY_TREE_SOURCES}) + +add_library(boost_property_tree INTERFACE) +add_library(Boost::property_tree ALIAS boost_property_tree) + +target_include_directories(boost_property_tree INTERFACE include) + +if(BOOST_SUPERPROJECT_VERSION) + # + # Building as part of Boost superproject tree, with Boost as dependency. + # + target_link_libraries(boost_property_tree + INTERFACE + Boost::any + Boost::assert + Boost::bind + Boost::config + Boost::core + Boost::format + Boost::iterator + Boost::mpl + Boost::multi_index + Boost::optional + Boost::range + Boost::serialization + Boost::static_assert + Boost::throw_exception + Boost::type_traits + ) + +elseif(BOOST_PROPERTY_TREE_IN_BOOST_TREE) + # + # Building inside Boost tree, out of Boost superproject tree, with Boost as dependency. + # e.g. on Travis or other CI, or when producing Visual Studio Solution and Projects. + # + get_filename_component(BOOST_ROOT ../.. ABSOLUTE) + set(BOOST_INCLUDEDIR ${BOOST_ROOT}) + set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage/lib) + find_package(Boost COMPONENTS serialization REQUIRED) + + target_include_directories(boost_property_tree INTERFACE ${BOOST_ROOT}) + target_link_directories(boost_property_tree INTERFACE ${BOOST_ROOT}/stage/lib) + +else() + # + # Building out of Boost tree, out of Boost superproject tree, with Boost as dependency. + # e.g. for packaging or added with add_subdirectory. + # + find_package(Boost REQUIRED + #COMPONENTS container system + ) + target_link_libraries(boost_property_tree + INTERFACE + Boost::boost + ) +endif() + +if(BUILD_TESTING) + include(CTest) + add_subdirectory(test) +endif() + +if(BOOST_PROPERTY_TREE_BUILD_EXAMPLES) + if (BOOST_SUPERPROJECT_VERSION) + message(STATUS "[property_tree] superproject build - skipping examples") + else() + add_subdirectory(examples) + endif() +endif() diff --git a/README.md b/README.md new file mode 100644 index 0000000..c1a1318 --- /dev/null +++ b/README.md @@ -0,0 +1,22 @@ +# Maintainer + +This library is currently maintained by [Richard Hodges](mailto:hodges.r@gmail.com) with generous support +from the C++ Alliance. + +# Build Status + +Branch | Status +--------|------- +develop | [![CI](https://github.com/boostorg/property_tree/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/property_tree/actions/workflows/ci.yml) +master | [![CI](https://github.com/boostorg/property_tree/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/property_tree/actions/workflows/ci.yml) + +# Licence + +This software is distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt). + +# Original Work + +This library is the work of Marcin Kalicinski and Sebastian Redl
+ +Copyright (C) 2002-2006 Marcin Kalicinski
+Copyright (C) 2009 Sebastian Redl diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in new file mode 100644 index 0000000..fdf3dec --- /dev/null +++ b/cmake/config.cmake.in @@ -0,0 +1,6 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) +find_dependency(Boost REQUIRED ) #COMPONENTS container system) + +include("${CMAKE_CURRENT_LIST_DIR}/boost_property_tree-targets.cmake") diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt new file mode 100644 index 0000000..b77bd64 --- /dev/null +++ b/examples/CMakeLists.txt @@ -0,0 +1,57 @@ +# +# Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) +# Copyright (c) 2021 Richard Hodges (hodges.r@gmail.com) +# +# 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) +# +# Official repository: https://github.com/boostorg/json +# + +source_group("test" FILES + custom_data_type.cpp + debug_settings.cpp + empty_ptree_trick.cpp + info_grammar_spirit.cpp + speed_test.cpp +) + +# + +add_executable(custom_data_type + custom_data_type.cpp +) +set_property(TARGET custom_data_type PROPERTY FOLDER "example") +target_link_libraries(custom_data_type PRIVATE Boost::property_tree) + +# + +add_executable(debug_settings + debug_settings.cpp +) +set_property(TARGET debug_settings PROPERTY FOLDER "example") +target_link_libraries(debug_settings PRIVATE Boost::property_tree) + +# + +add_executable(empty_ptree_trick + empty_ptree_trick.cpp +) +set_property(TARGET empty_ptree_trick PROPERTY FOLDER "example") +target_link_libraries(empty_ptree_trick PRIVATE Boost::property_tree) + +# + +add_executable(info_grammar_spirit + info_grammar_spirit.cpp +) +set_property(TARGET info_grammar_spirit PROPERTY FOLDER "example") +target_link_libraries(info_grammar_spirit PRIVATE Boost::property_tree) + +# + +add_executable(speed_test + speed_test.cpp +) +set_property(TARGET speed_test PROPERTY FOLDER "example") +target_link_libraries(speed_test PRIVATE Boost::property_tree) diff --git a/examples/empty_ptree_trick.cpp b/examples/empty_ptree_trick.cpp index 37285b2..dd2c21a 100644 --- a/examples/empty_ptree_trick.cpp +++ b/examples/empty_ptree_trick.cpp @@ -16,13 +16,15 @@ using namespace boost::property_tree; -// Process settings using empty ptree trick. Note that it is considerably simpler + static ptree dflt; + + // Process settings using empty ptree trick. Note that it is considerably simpler // than version which does not use the "trick" void process_settings(const std::string &filename) { ptree pt; - read_info(filename, pt); - const ptree &settings = pt.get_child("settings", empty_ptree()); + read_info(filename, pt); + const ptree &settings = pt.get_child("settings", dflt); std::cout << "\n Processing " << filename << std::endl; std::cout << " Setting 1 is " << settings.get("setting1", 0) << std::endl; std::cout << " Setting 2 is " << settings.get("setting2", 0.0) << std::endl; diff --git a/meta/libraries.json b/meta/libraries.json index 025c043..cd6f52f 100644 --- a/meta/libraries.json +++ b/meta/libraries.json @@ -11,6 +11,7 @@ "Data" ], "maintainers": [ - "Sebastian Redl " - ] + "Richard Hodges " + ], + "cxxstd": "03" } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 0000000..63c6bbc --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,82 @@ +# +# Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) +# Copyright (c) 2021 Richard Hodges (hodges.r@gmail.com) +# +# 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) +# +# Official repository: https://github.com/boostorg/json +# + +file(GLOB_RECURSE BOOST_PROPERTY_TREE_TESTS_FILES CONFIGURE_DEPENDS Jamfile *.cpp *.hpp) +list(FILTER BOOST_PROPERTY_TREE_TESTS_FILES EXCLUDE REGEX "^${CMAKE_CURRENT_SOURCE_DIR}/cmake_install_test/.*$") + +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES ${BOOST_PROPERTY_TREE_TESTS_FILES}) + +macro(PTREE_TEST name) + add_executable("${name}" ${ARGN}) + target_include_directories("${name}" PRIVATE .) + target_link_libraries("${name}" PRIVATE Boost::property_tree Boost::serialization) + add_test(NAME "property_tree-${name}" COMMAND "${name}") +endmacro() + +PTREE_TEST(test-multi test_multi_module1.cpp test_multi_module2.cpp) +PTREE_TEST(test-property-tree test_property_tree.cpp test_property_tree.hpp) +PTREE_TEST(test-info-parser test_info_parser.cpp) +PTREE_TEST(test-json-parser test_json_parser.cpp) +PTREE_TEST(test-json-parser2 test_json_parser2.cpp) +PTREE_TEST(test-ini-parser test_ini_parser.cpp) +PTREE_TEST(test-xml-parser-rapidxml test_xml_parser_rapidxml.cpp) + +#[[ +add_executable(tests ${BOOST_PROPERTY_TREE_TESTS_FILES}) +target_include_directories(tests PRIVATE .) +target_link_libraries(tests PRIVATE Boost::property_tree Boost::serialization Boost::unit_test_framework) +add_test(NAME property_tree-tests COMMAND tests) +]] + +#[[ +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES limits.cpp main.cpp) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/../src PREFIX "" FILES ../src/src.cpp) +add_executable(limits limits.cpp main.cpp ../src/src.cpp Jamfile) + +target_compile_features(limits PUBLIC cxx_constexpr) + +target_include_directories(limits PRIVATE ../include .) +target_compile_definitions(limits PRIVATE + BOOST_PROPERTY_TREE_MAX_STRING_SIZE=1000 + BOOST_PROPERTY_TREE_MAX_STRUCTURED_SIZE=20 + BOOST_PROPERTY_TREE_STACK_BUFFER_SIZE=256 + BOOST_PROPERTY_TREE_NO_LIB=1 +) +]] + +if(BOOST_SUPERPROJECT_VERSION) +#[[ + target_link_libraries(limits + PRIVATE + Boost::align + Boost::assert + Boost::config + Boost::container + Boost::exception + Boost::system + Boost::throw_exception + Boost::utility + ) +]] +elseif(BOOST_PROPERTY_TREE_IN_BOOST_TREE) +#[[ + target_include_directories(limits PRIVATE ${BOOST_ROOT}) + target_link_directories(limits PRIVATE ${BOOST_ROOT}/stage/lib) +]] +else() +#[[ + target_link_libraries(limits + PRIVATE + Boost::system + Boost::container + ) +]] +endif() + diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index af25731..c332508 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -19,7 +19,7 @@ test-suite "property_tree" : [ run test_property_tree.cpp /boost/serialization//boost_serialization ] [ run test_info_parser.cpp ] [ run test_json_parser.cpp ] - [ run test_json_parser2.cpp /boost/test//boost_unit_test_framework ] + [ run test_json_parser2.cpp ] [ run test_ini_parser.cpp ] [ run test_xml_parser_rapidxml.cpp ] diff --git a/test/test_info_parser.cpp b/test/test_info_parser.cpp index 798f09e..4590884 100644 --- a/test/test_info_parser.cpp +++ b/test/test_info_parser.cpp @@ -229,14 +229,14 @@ void test_info_parser() Ptree pt, default_pt; pt.put_value(1); default_pt.put_value(2); - BOOST_CHECK(pt != default_pt); + BOOST_TEST(pt != default_pt); read_info("nonexisting file.nonexisting file", pt, default_pt); - BOOST_CHECK(pt == default_pt); + BOOST_TEST(pt == default_pt); } } -int test_main(int argc, char *argv[]) +int main() { using namespace boost::property_tree; test_info_parser(); @@ -245,5 +245,5 @@ int test_main(int argc, char *argv[]) test_info_parser(); test_info_parser(); #endif - return 0; + return boost::report_errors(); } diff --git a/test/test_ini_parser.cpp b/test/test_ini_parser.cpp index 2edb48c..3d7a8b6 100644 --- a/test/test_ini_parser.cpp +++ b/test/test_ini_parser.cpp @@ -204,12 +204,12 @@ void test_other_trees() s.seekg(0, std::ios_base::beg); ptree result; read_ini(s, result); - BOOST_CHECK(result.get("section.innerkey", "bad") == "v1"); - BOOST_CHECK(result.get("nosection", "bad") == "v2"); + BOOST_TEST(result.get("section.innerkey", "bad") == "v1"); + BOOST_TEST(result.get("nosection", "bad") == "v2"); } } -int test_main(int argc, char *argv[]) +int main() { test_ini_parser(); test_ini_parser(); @@ -221,6 +221,6 @@ int test_main(int argc, char *argv[]) test_unmappable_trees(); test_other_trees(); - return 0; + return boost::report_errors(); } diff --git a/test/test_json_parser.cpp b/test/test_json_parser.cpp index 3c14d9b..6a6ddd2 100644 --- a/test/test_json_parser.cpp +++ b/test/test_json_parser.cpp @@ -411,24 +411,24 @@ void test_escaping_utf8() std::string str = "\xD0\x9C\xD0\xB0\xD0\xBC\xD0\xB0 " "\xD0\xBC\xD1\x8B\xD0\xBB\xD0\xB0 \xD1\x80\xD0\xB0\xD0\xBC\xD1\x83"; // Should NOT escape UTF-8 - BOOST_CHECK(boost::property_tree::json_parser::create_escapes(str) == str); + BOOST_TEST(boost::property_tree::json_parser::create_escapes(str) == str); } void test_escaping_wide() { // Should NOT escape characters within ASCII range. std::wstring str1 = L"I am wstring with ASCII"; - BOOST_CHECK(boost::property_tree::json_parser::create_escapes(str1) == str1); + BOOST_TEST(boost::property_tree::json_parser::create_escapes(str1) == str1); // Should escape characters outside ASCII range - this is NOT utf-8 // This is cyrillic text std::wstring str2 = L"\u041C\u0430\u043C\u0430 " L"\u043C\u044B\u043B\u0430 \u0440\u0430\u043C\u0443"; - BOOST_CHECK(boost::property_tree::json_parser::create_escapes(str2) == + BOOST_TEST(boost::property_tree::json_parser::create_escapes(str2) == L"\\u041C\\u0430\\u043C\\u0430 " L"\\u043C\\u044B\\u043B\\u0430 \\u0440\\u0430\\u043C\\u0443"); } -int test_main(int argc, char *argv[]) +int main(int , char *[]) { using namespace boost::property_tree; test_json_parser(); @@ -439,5 +439,5 @@ int test_main(int argc, char *argv[]) test_json_parser(); test_escaping_wide(); #endif - return 0; + return boost::report_errors(); } diff --git a/test/test_json_parser2.cpp b/test/test_json_parser2.cpp index 248ba46..75c8abc 100644 --- a/test/test_json_parser2.cpp +++ b/test/test_json_parser2.cpp @@ -4,9 +4,7 @@ #include #include "prefixing_callbacks.hpp" -#define BOOST_TEST_NO_MAIN -#include -#include +#include #include #include @@ -14,6 +12,7 @@ #include #include #include +#include using namespace boost::property_tree; @@ -126,105 +125,125 @@ struct prefixing_parser #define BOM_N "\xef\xbb\xbf" #define BOM_W L"\xfeff" -namespace boost { namespace test_tools { namespace tt_detail { - template<> - struct print_log_value { - void operator()(std::ostream& os, const std::wstring& s) { - print_log_value()(os, s.c_str()); - } - }; -}}} -BOOST_TEST_DONT_PRINT_LOG_VALUE(ptree::iterator) -BOOST_TEST_DONT_PRINT_LOG_VALUE(ptree::const_iterator) -BOOST_TEST_DONT_PRINT_LOG_VALUE(wptree::iterator) -BOOST_TEST_DONT_PRINT_LOG_VALUE(wptree::const_iterator) - -BOOST_AUTO_TEST_CASE(null_parse_result_is_input) { +static void +test_null_parse_result_is_input() +{ std::string parsed; standard_parser p; - BOOST_REQUIRE(p.parse_null("null", parsed)); - BOOST_CHECK_EQUAL("null", parsed); + BOOST_TEST(p.parse_null("null", parsed)); + BOOST_TEST_EQ("null", parsed); } -BOOST_AUTO_TEST_CASE(uses_traits_from_null) +static void +test_uses_traits_from_null() { std::string parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_null("null", parsed)); - BOOST_CHECK_EQUAL("_:null", parsed); + BOOST_TEST(p.parse_null("null", parsed)); + BOOST_TEST_EQ("_:null", parsed); } -BOOST_AUTO_TEST_CASE(null_parse_skips_bom) { +static void +test_null_parse_skips_bom() +{ std::string parsed; standard_parser p; - BOOST_REQUIRE(p.parse_null(BOM_N "null", parsed)); - BOOST_CHECK_EQUAL("null", parsed); + BOOST_TEST(p.parse_null(BOM_N "null", parsed)); + BOOST_TEST_EQ("null", parsed); } -BOOST_AUTO_TEST_CASE(null_parse_result_is_input_w) { +static void +test_null_parse_result_is_input_w() +{ std::wstring parsed; standard_parser p; - BOOST_REQUIRE(p.parse_null(L"null", parsed)); - BOOST_CHECK_EQUAL(L"null", parsed); + BOOST_TEST(p.parse_null(L"null", parsed)); + BOOST_TEST(parsed == L"null"); } -BOOST_AUTO_TEST_CASE(uses_traits_from_null_w) +static void +test_uses_traits_from_null_w() { std::wstring parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_null(L"null", parsed)); - BOOST_CHECK_EQUAL(L"_:null", parsed); + BOOST_TEST(p.parse_null(L"null", parsed)); + BOOST_TEST(parsed == L"_:null"); } -BOOST_AUTO_TEST_CASE(null_parse_skips_bom_w) { +static void +test_null_parse_skips_bom_w() +{ std::wstring parsed; standard_parser p; - BOOST_REQUIRE(p.parse_null(BOM_W L"null", parsed)); - BOOST_CHECK_EQUAL(L"null", parsed); + BOOST_TEST(p.parse_null(BOM_W L"null", parsed)); + BOOST_TEST(parsed == L"null"); } -void boolean_parse_result_is_input_n(const char* param) { - std::string parsed; - standard_parser p; - BOOST_REQUIRE(p.parse_boolean(param, parsed)); - BOOST_CHECK_EQUAL(param, parsed); +template +static void +test_boolean_parse_result_is_input_n(const std::string (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + std::string parsed; + standard_parser p; + BOOST_TEST(p.parse_boolean(param[i], parsed)); + BOOST_TEST_EQ(param[i], parsed); + } } -const char* const booleans_n[] = { "true", "false" }; +const std::string +booleans_n[] = { "true", "false" }; -BOOST_AUTO_TEST_CASE(uses_traits_from_boolean_n) +static void +test_uses_traits_from_boolean_n() { std::string parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_boolean("true", parsed)); - BOOST_CHECK_EQUAL("b:true", parsed); + BOOST_TEST(p.parse_boolean("true", parsed)); + BOOST_TEST_EQ("b:true", parsed); } -void boolean_parse_result_is_input_w(const wchar_t* param) { - std::wstring parsed; - standard_parser p; - BOOST_REQUIRE(p.parse_boolean(param, parsed)); - BOOST_CHECK_EQUAL(param, parsed); +template +static void +test_boolean_parse_result_is_input_w(const std::wstring (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + std::wstring parsed; + standard_parser p; + BOOST_TEST(p.parse_boolean(param[i], parsed)); + BOOST_TEST(param[i] == parsed); + } } -const wchar_t* const booleans_w[] = { L"true", L"false" }; +const std::wstring +booleans_w[] = { L"true", L"false" }; -BOOST_AUTO_TEST_CASE(uses_traits_from_boolean_w) +static void +test_uses_traits_from_boolean_w() { std::wstring parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_boolean(L"true", parsed)); - BOOST_CHECK_EQUAL(L"b:true", parsed); + BOOST_TEST(p.parse_boolean(L"true", parsed)); + BOOST_TEST(parsed == L"b:true"); } -void number_parse_result_is_input_n(const char* param) { - std::string parsed; - standard_parser p; - BOOST_REQUIRE(p.parse_number(param, parsed)); - BOOST_CHECK_EQUAL(param, parsed); +template +static void +test_number_parse_result_is_input_n(std::string const (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + std::string parsed; + standard_parser p; + BOOST_TEST(p.parse_number(param[i], parsed)); + BOOST_TEST_EQ(param[i], parsed); + } } -const char* const numbers_n[] = { +std::string const +numbers_n[] = { "0", "-0", "1824", @@ -235,22 +254,29 @@ const char* const numbers_n[] = { "1.1e134" }; -BOOST_AUTO_TEST_CASE(uses_traits_from_number_n) +static void +test_uses_traits_from_number_n() { std::string parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_number("12345", parsed)); - BOOST_CHECK_EQUAL("n:12345", parsed); + BOOST_TEST(p.parse_number("12345", parsed)); + BOOST_TEST_EQ("n:12345", parsed); } -void number_parse_result_is_input_w(const wchar_t* param) { - std::wstring parsed; - standard_parser p; - BOOST_REQUIRE(p.parse_number(param, parsed)); - BOOST_CHECK_EQUAL(param, parsed); +template +static void +test_number_parse_result_is_input_w(const std::wstring (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + std::wstring parsed; + standard_parser p; + BOOST_TEST(p.parse_number(param[i], parsed)); + BOOST_TEST(parsed == param[i]); + } } -const wchar_t* const numbers_w[] = { +std::wstring const numbers_w[] = { L"0", L"-0", L"1824", @@ -261,12 +287,13 @@ const wchar_t* const numbers_w[] = { L"1.1e134" }; -BOOST_AUTO_TEST_CASE(uses_traits_from_number_w) +static void +test_uses_traits_from_number_w() { std::wstring parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_number(L"12345", parsed)); - BOOST_CHECK_EQUAL(L"n:12345", parsed); + BOOST_TEST(p.parse_number(L"12345", parsed)); + BOOST_TEST(parsed == L"n:12345"); } struct string_input_n { @@ -274,11 +301,16 @@ struct string_input_n { const char* expected; }; -void string_parsed_correctly_n(string_input_n param) { - std::string parsed; - standard_parser p; - BOOST_REQUIRE(p.parse_string(param.encoded, parsed)); - BOOST_CHECK_EQUAL(param.expected, parsed); +template +void test_string_parsed_correctly_n(string_input_n const (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + std::string parsed; + standard_parser p; + BOOST_TEST(p.parse_string(param[i].encoded, parsed)); + BOOST_TEST_EQ(param[i].expected, parsed); + } } const string_input_n strings_n[] = { @@ -297,12 +329,13 @@ const string_input_n strings_n[] = { {"\xef\xbb\xbf\"\"", ""} // BOM }; -BOOST_AUTO_TEST_CASE(uses_string_callbacks) +static void +test_uses_string_callbacks() { std::string parsed; prefixing_parser p; - BOOST_REQUIRE(p.parse_string("\"a\"", parsed)); - BOOST_CHECK_EQUAL("s:a", parsed); + BOOST_TEST(p.parse_string("\"a\"", parsed)); + BOOST_TEST_EQ("s:a", parsed); } struct string_input_w { @@ -310,11 +343,17 @@ struct string_input_w { const wchar_t* expected; }; -void string_parsed_correctly_w(string_input_w param) { - std::wstring parsed; - standard_parser p; - BOOST_REQUIRE(p.parse_string(param.encoded, parsed)); - BOOST_CHECK_EQUAL(param.expected, parsed); +template +void +test_string_parsed_correctly_w(string_input_w const (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + std::wstring parsed; + standard_parser p; + if(BOOST_TEST(p.parse_string(param[i].encoded, parsed))) + BOOST_TEST(param[i].expected == parsed); + } } const string_input_w strings_w[] = { @@ -332,137 +371,165 @@ const string_input_w strings_w[] = { {L"\xfeff\"\"", L""} // BOM }; -BOOST_AUTO_TEST_CASE(empty_array) { +static void +test_empty_array() +{ ptree tree; standard_parser p; const char* input = " [ ]"; - BOOST_REQUIRE(p.parse_array(input, tree)); - BOOST_CHECK_EQUAL("", tree.data()); - BOOST_CHECK_EQUAL(0u, tree.size()); + BOOST_TEST(p.parse_array(input, tree)); + BOOST_TEST_EQ("", tree.data()); + BOOST_TEST_EQ(0u, tree.size()); } -BOOST_AUTO_TEST_CASE(array_gets_tagged) { +static void +test_array_gets_tagged() +{ wptree tree; prefixing_parser p; const wchar_t* input = L" [ ]"; - BOOST_REQUIRE(p.parse_array(input, tree)); - BOOST_CHECK_EQUAL(L"a:", tree.data()); - BOOST_CHECK_EQUAL(0u, tree.size()); + BOOST_TEST(p.parse_array(input, tree)); + BOOST_TEST(tree.data() == L"a:"); + BOOST_TEST_EQ(0u, tree.size()); } -BOOST_AUTO_TEST_CASE(array_with_values) { +static void +test_array_with_values() +{ wptree tree; standard_parser p; const wchar_t* input = L"[\n" L" 123, \"abc\" ,true ,\n" L" null\n" L" ]"; - BOOST_REQUIRE(p.parse_array(input, tree)); - BOOST_REQUIRE_EQUAL(4u, tree.size()); + if(!BOOST_TEST(p.parse_array(input, tree))) + return; + if(!BOOST_TEST_EQ(4u, tree.size())) + return; wptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL(L"", it->first); - BOOST_CHECK_EQUAL(L"123", it->second.data()); + BOOST_TEST(it->first == L""); + BOOST_TEST(it->second.data() == L"123"); ++it; - BOOST_CHECK_EQUAL(L"", it->first); - BOOST_CHECK_EQUAL(L"abc", it->second.data()); + BOOST_TEST(it->first == L""); + BOOST_TEST(it->second.data() == L"abc"); ++it; - BOOST_CHECK_EQUAL(L"", it->first); - BOOST_CHECK_EQUAL(L"true", it->second.data()); + BOOST_TEST(it->first == L""); + BOOST_TEST(it->second.data() == L"true"); ++it; - BOOST_CHECK_EQUAL(L"", it->first); - BOOST_CHECK_EQUAL(L"null", it->second.data()); + BOOST_TEST(it->first == L""); + BOOST_TEST(it->second.data() == L"null"); ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + BOOST_TEST(tree.end() == it); } -BOOST_AUTO_TEST_CASE(array_values_get_tagged) { +static void +test_array_values_get_tagged() +{ ptree tree; prefixing_parser p; const char* input = "[\n" " 123, \"abc\" ,true ,\n" " null\n" " ]"; - BOOST_REQUIRE(p.parse_array(input, tree)); - BOOST_REQUIRE_EQUAL(4u, tree.size()); - BOOST_CHECK_EQUAL("a:", tree.data()); - ptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL("", it->first); - BOOST_CHECK_EQUAL("n:123", it->second.data()); - ++it; - BOOST_CHECK_EQUAL("", it->first); - BOOST_CHECK_EQUAL("s:abc", it->second.data()); - ++it; - BOOST_CHECK_EQUAL("", it->first); - BOOST_CHECK_EQUAL("b:true", it->second.data()); - ++it; - BOOST_CHECK_EQUAL("", it->first); - BOOST_CHECK_EQUAL("_:null", it->second.data()); - ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + if(BOOST_TEST(p.parse_array(input, tree))) + if(BOOST_TEST_EQ(4u, tree.size())) + { + BOOST_TEST_EQ("a:", tree.data()); + ptree::iterator it = tree.begin(); + BOOST_TEST_EQ("", it->first); + BOOST_TEST_EQ("n:123", it->second.data()); + ++it; + BOOST_TEST_EQ("", it->first); + BOOST_TEST_EQ("s:abc", it->second.data()); + ++it; + BOOST_TEST_EQ("", it->first); + BOOST_TEST_EQ("b:true", it->second.data()); + ++it; + BOOST_TEST_EQ("", it->first); + BOOST_TEST_EQ("_:null", it->second.data()); + ++it; + BOOST_TEST(tree.end() == it); + } } -BOOST_AUTO_TEST_CASE(nested_array) { +static void +test_nested_array() +{ ptree tree; standard_parser p; const char* input = "[[1,2],3,[4,5]]"; - BOOST_REQUIRE(p.parse_array(input, tree)); - BOOST_REQUIRE_EQUAL(3u, tree.size()); + if(!BOOST_TEST(p.parse_array(input, tree))) + return; + if(!BOOST_TEST_EQ(3u, tree.size())) + return; ptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL("", it->first); + BOOST_TEST_EQ("", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); + BOOST_TEST_EQ("", sub.data()); + if(!BOOST_TEST_EQ(2u, sub.size())) + return; ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("1", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("1", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("2", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("2", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST(sub.end() == iit); } ++it; - BOOST_CHECK_EQUAL("", it->first); - BOOST_CHECK_EQUAL("3", it->second.data()); + BOOST_TEST_EQ("", it->first); + BOOST_TEST_EQ("3", it->second.data()); ++it; - BOOST_CHECK_EQUAL("", it->first); + BOOST_TEST_EQ("", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); + BOOST_TEST_EQ("", sub.data()); + if(!BOOST_TEST_EQ(2u, sub.size())) + return; ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("4", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("4", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("5", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("5", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST(sub.end() == iit); } ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + BOOST_TEST(tree.end() == it); } -BOOST_AUTO_TEST_CASE(empty_object) { +static void +test_empty_object() +{ ptree tree; standard_parser p; const char* input = " { }"; - BOOST_REQUIRE(p.parse_object(input, tree)); - BOOST_CHECK_EQUAL("", tree.data()); - BOOST_CHECK_EQUAL(0u, tree.size()); + if(BOOST_TEST(p.parse_object(input, tree))) + { + BOOST_TEST_EQ("", tree.data()); + BOOST_TEST_EQ(0u, tree.size()); + } } -BOOST_AUTO_TEST_CASE(object_gets_tagged) { +static void +test_object_gets_tagged() +{ wptree tree; prefixing_parser p; const wchar_t* input = L" { }"; - BOOST_REQUIRE(p.parse_object(input, tree)); - BOOST_CHECK_EQUAL(L"o:", tree.data()); - BOOST_CHECK_EQUAL(0u, tree.size()); + if(BOOST_TEST(p.parse_object(input, tree))) + { + BOOST_TEST(tree.data() == L"o:"); + BOOST_TEST_EQ(0u, tree.size()); + } } -BOOST_AUTO_TEST_CASE(object_with_values) { +static void +test_object_with_values() +{ wptree tree; standard_parser p; const wchar_t* input = L"{\n" @@ -470,180 +537,210 @@ L" \"1\":123, \"2\"\n" L" :\"abc\" ,\"3\": true ,\n" L" \"4\" : null\n" L" }"; - BOOST_REQUIRE(p.parse_object(input, tree)); - BOOST_REQUIRE_EQUAL(4u, tree.size()); - wptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL(L"1", it->first); - BOOST_CHECK_EQUAL(L"123", it->second.data()); - ++it; - BOOST_CHECK_EQUAL(L"2", it->first); - BOOST_CHECK_EQUAL(L"abc", it->second.data()); - ++it; - BOOST_CHECK_EQUAL(L"3", it->first); - BOOST_CHECK_EQUAL(L"true", it->second.data()); - ++it; - BOOST_CHECK_EQUAL(L"4", it->first); - BOOST_CHECK_EQUAL(L"null", it->second.data()); - ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + if(BOOST_TEST(p.parse_object(input, tree))) + if(BOOST_TEST_EQ(4u, tree.size())) + { + wptree::iterator it = tree.begin(); + BOOST_TEST(it->first == L"1"); + BOOST_TEST(it->second.data() == L"123"); + ++it; + BOOST_TEST(it->first == L"2"); + BOOST_TEST(it->second.data() == L"abc"); + ++it; + BOOST_TEST(it->first == L"3"); + BOOST_TEST(it->second.data() == L"true"); + ++it; + BOOST_TEST(it->first == L"4"); + BOOST_TEST(it->second.data() == L"null"); + ++it; + BOOST_TEST(tree.end() == it); + } } -BOOST_AUTO_TEST_CASE(object_values_get_tagged) { +static void +test_object_values_get_tagged() +{ ptree tree; prefixing_parser p; const char* input = "{\n" "\"1\": 123, \"2\": \"abc\" ,\"3\": true ,\n" "\"4\": null\n" "}"; - BOOST_REQUIRE(p.parse_object(input, tree)); - BOOST_REQUIRE_EQUAL(4u, tree.size()); - BOOST_CHECK_EQUAL("o:", tree.data()); - ptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL("1", it->first); - BOOST_CHECK_EQUAL("n:123", it->second.data()); - ++it; - BOOST_CHECK_EQUAL("2", it->first); - BOOST_CHECK_EQUAL("s:abc", it->second.data()); - ++it; - BOOST_CHECK_EQUAL("3", it->first); - BOOST_CHECK_EQUAL("b:true", it->second.data()); - ++it; - BOOST_CHECK_EQUAL("4", it->first); - BOOST_CHECK_EQUAL("_:null", it->second.data()); - ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + if(BOOST_TEST(p.parse_object(input, tree))) + if(BOOST_TEST_EQ(4u, tree.size())) + { + BOOST_TEST_EQ("o:", tree.data()); + ptree::iterator it = tree.begin(); + BOOST_TEST_EQ("1", it->first); + BOOST_TEST_EQ("n:123", it->second.data()); + ++it; + BOOST_TEST_EQ("2", it->first); + BOOST_TEST_EQ("s:abc", it->second.data()); + ++it; + BOOST_TEST_EQ("3", it->first); + BOOST_TEST_EQ("b:true", it->second.data()); + ++it; + BOOST_TEST_EQ("4", it->first); + BOOST_TEST_EQ("_:null", it->second.data()); + ++it; + BOOST_TEST(tree.end() == it); + } } -BOOST_AUTO_TEST_CASE(nested_object) { +static void +test_nested_object() +{ ptree tree; standard_parser p; const char* input = "{\"a\":{\"b\":1,\"c\":2},\"d\":3,\"e\":{\"f\":4,\"g\":5}}"; - BOOST_REQUIRE(p.parse_object(input, tree)); - BOOST_REQUIRE_EQUAL(3u, tree.size()); + if(!BOOST_TEST(p.parse_object(input, tree))) + return; + if(!BOOST_TEST_EQ(3u, tree.size())) + return; ptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL("a", it->first); + BOOST_TEST_EQ("a", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); + BOOST_TEST_EQ("", sub.data()); + if(!BOOST_TEST_EQ(2u, sub.size())) + return; ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("b", iit->first); - BOOST_CHECK_EQUAL("1", iit->second.data()); + BOOST_TEST_EQ("b", iit->first); + BOOST_TEST_EQ("1", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL("c", iit->first); - BOOST_CHECK_EQUAL("2", iit->second.data()); + BOOST_TEST_EQ("c", iit->first); + BOOST_TEST_EQ("2", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST(sub.end() == iit); } ++it; - BOOST_CHECK_EQUAL("d", it->first); - BOOST_CHECK_EQUAL("3", it->second.data()); + BOOST_TEST_EQ("d", it->first); + BOOST_TEST_EQ("3", it->second.data()); ++it; - BOOST_CHECK_EQUAL("e", it->first); + BOOST_TEST_EQ("e", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); + BOOST_TEST_EQ("", sub.data()); + if(!BOOST_TEST_EQ(2u, sub.size())) + return; ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("f", iit->first); - BOOST_CHECK_EQUAL("4", iit->second.data()); + BOOST_TEST_EQ("f", iit->first); + BOOST_TEST_EQ("4", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL("g", iit->first); - BOOST_CHECK_EQUAL("5", iit->second.data()); + BOOST_TEST_EQ("g", iit->first); + BOOST_TEST_EQ("5", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST(sub.end() == iit); } ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + BOOST_TEST(tree.end() == it); } -BOOST_AUTO_TEST_CASE(array_in_object) { +static void +test_array_in_object() +{ ptree tree; standard_parser p; const char* input = "{\"a\":[1,2],\"b\":3,\"c\":[4,5]}"; - BOOST_REQUIRE(p.parse_object(input, tree)); - BOOST_REQUIRE_EQUAL(3u, tree.size()); + if(!BOOST_TEST(p.parse_object(input, tree))) + return; + if(!BOOST_TEST_EQ(3u, tree.size())) + return; ptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL("a", it->first); + BOOST_TEST_EQ("a", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); - ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("1", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("2", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST_EQ("", sub.data()); + if(BOOST_TEST_EQ(2u, sub.size())) + { + ptree::iterator iit = sub.begin(); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("1", iit->second.data()); + ++iit; + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("2", iit->second.data()); + ++iit; + BOOST_TEST(sub.end() == iit); + } } ++it; - BOOST_CHECK_EQUAL("b", it->first); - BOOST_CHECK_EQUAL("3", it->second.data()); + BOOST_TEST_EQ("b", it->first); + BOOST_TEST_EQ("3", it->second.data()); ++it; - BOOST_CHECK_EQUAL("c", it->first); + BOOST_TEST_EQ("c", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); - ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("4", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("5", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST_EQ("", sub.data()); + if(BOOST_TEST_EQ(2u, sub.size())) + { + ptree::iterator iit = sub.begin(); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("4", iit->second.data()); + ++iit; + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("5", iit->second.data()); + ++iit; + BOOST_TEST(sub.end() == iit); + } } ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + BOOST_TEST(tree.end() == it); } -BOOST_AUTO_TEST_CASE(object_in_array) { +static void +test_object_in_array() +{ ptree tree; standard_parser p; const char* input = "[{\"a\":1,\"b\":2},3,{\"c\":4,\"d\":5}]"; - BOOST_REQUIRE(p.parse_array(input, tree)); - BOOST_REQUIRE_EQUAL(3u, tree.size()); + if(!BOOST_TEST(p.parse_array(input, tree))) + return; + if(!BOOST_TEST_EQ(3u, tree.size())) + return; ptree::iterator it = tree.begin(); - BOOST_CHECK_EQUAL("", it->first); + BOOST_TEST_EQ("", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); - ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("a", iit->first); - BOOST_CHECK_EQUAL("1", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL("b", iit->first); - BOOST_CHECK_EQUAL("2", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST_EQ("", sub.data()); + if(BOOST_TEST_EQ(2u, sub.size())) + { + ptree::iterator iit = sub.begin(); + BOOST_TEST_EQ("a", iit->first); + BOOST_TEST_EQ("1", iit->second.data()); + ++iit; + BOOST_TEST_EQ("b", iit->first); + BOOST_TEST_EQ("2", iit->second.data()); + ++iit; + BOOST_TEST(sub.end() == iit); + } } ++it; - BOOST_CHECK_EQUAL("", it->first); - BOOST_CHECK_EQUAL("3", it->second.data()); + BOOST_TEST_EQ("", it->first); + BOOST_TEST_EQ("3", it->second.data()); ++it; - BOOST_CHECK_EQUAL("", it->first); + BOOST_TEST_EQ("", it->first); { ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(2u, sub.size()); - ptree::iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("c", iit->first); - BOOST_CHECK_EQUAL("4", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL("d", iit->first); - BOOST_CHECK_EQUAL("5", iit->second.data()); - ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST_EQ("", sub.data()); + if(BOOST_TEST_EQ(2u, sub.size())) + { + ptree::iterator iit = sub.begin(); + BOOST_TEST_EQ("c", iit->first); + BOOST_TEST_EQ("4", iit->second.data()); + ++iit; + BOOST_TEST_EQ("d", iit->first); + BOOST_TEST_EQ("5", iit->second.data()); + ++iit; + BOOST_TEST(sub.end() == iit); + } } ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + BOOST_TEST(tree.end() == it); } -BOOST_AUTO_TEST_CASE(parser_works_with_input_iterators) { +static void +test_parser_works_with_input_iterators() +{ const char* input = " {\n" " \"1\":123, \"2\"\n" " :\"abc\" ,\"3\": true ,\n" @@ -664,39 +761,41 @@ BOOST_AUTO_TEST_CASE(parser_works_with_input_iterators) { p.parse_value(); const ptree& tree = callbacks.output(); - BOOST_REQUIRE_EQUAL(5u, tree.size()); + if(!BOOST_TEST_EQ(5u, tree.size())) + return; ptree::const_iterator it = tree.begin(); - BOOST_CHECK_EQUAL("1", it->first); - BOOST_CHECK_EQUAL("123", it->second.data()); + BOOST_TEST_EQ("1", it->first); + BOOST_TEST_EQ("123", it->second.data()); ++it; - BOOST_CHECK_EQUAL("2", it->first); - BOOST_CHECK_EQUAL("abc", it->second.data()); + BOOST_TEST_EQ("2", it->first); + BOOST_TEST_EQ("abc", it->second.data()); ++it; - BOOST_CHECK_EQUAL("3", it->first); - BOOST_CHECK_EQUAL("true", it->second.data()); + BOOST_TEST_EQ("3", it->first); + BOOST_TEST_EQ("true", it->second.data()); ++it; - BOOST_CHECK_EQUAL("4", it->first); - BOOST_CHECK_EQUAL("null", it->second.data()); + BOOST_TEST_EQ("4", it->first); + BOOST_TEST_EQ("null", it->second.data()); ++it; - BOOST_CHECK_EQUAL("5", it->first); + BOOST_TEST_EQ("5", it->first); { const ptree& sub = it->second; - BOOST_CHECK_EQUAL("", sub.data()); - BOOST_REQUIRE_EQUAL(3u, sub.size()); + BOOST_TEST_EQ("", sub.data()); + if(!BOOST_TEST_EQ(3u, sub.size())) + return; ptree::const_iterator iit = sub.begin(); - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("1", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("1", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("23", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("23", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL("", iit->first); - BOOST_CHECK_EQUAL("456", iit->second.data()); + BOOST_TEST_EQ("", iit->first); + BOOST_TEST_EQ("456", iit->second.data()); ++iit; - BOOST_CHECK_EQUAL(sub.end(), iit); + BOOST_TEST(sub.end() == iit); } ++it; - BOOST_CHECK_EQUAL(tree.end(), it); + BOOST_TEST(tree.end() == it); } struct bad_parse_n { @@ -704,19 +803,28 @@ struct bad_parse_n { const char* message_substring; }; -void parse_error_thrown_with_message_n(bad_parse_n param) { - try { - standard_parser p; - ptree dummy; - p.parse_value(param.json, dummy); - BOOST_FAIL("expected exception"); - } catch (json_parser::json_parser_error& e) { - std::string message = e.message(); - BOOST_CHECK_MESSAGE(message.find(param.message_substring) != - std::string::npos, - "bad error message on input '" << param.json - << "', need: '" << param.message_substring - << "' but found '" << message << "'"); +template +void test_parse_error_thrown_with_message_n(bad_parse_n const (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + try { + standard_parser p; + ptree dummy; + p.parse_value(param[i].json, dummy); + BOOST_ERROR("expected exception"); + } catch (json_parser::json_parser_error& e) { + std::string message = e.message(); + if(message.find(param[i].message_substring) == + std::string::npos) + { + std::ostringstream ss; + ss << "bad error message on input '" << param[i].json + << "', need: '" << param[i].message_substring + << "' but found '" << message << "'"; + BOOST_ERROR(ss.str().c_str()); + } + } } } @@ -812,23 +920,53 @@ struct bad_parse_w { const char* message_substring; }; -void parse_error_thrown_with_message_w(bad_parse_w param) { - try { - standard_parser p; - wptree dummy; - p.parse_value(param.json, dummy); - BOOST_FAIL("expected exception"); - } catch (json_parser::json_parser_error& e) { - std::string message = e.message(); - BOOST_CHECK_MESSAGE(message.find(param.message_substring) != - std::string::npos, - "bad error message on input '" << param.json - << "', need: '" << param.message_substring - << "' but found '" << message << "'"); +struct do_narrow +{ + char operator()(std::wstring::value_type w) const + { + unsigned long u = static_cast(w); + if (u < 32 || u > 126) + return '?'; + else + return static_cast(u); + } +}; +static std::string +make_narrow(std::wstring const& in) +{ + std::string result(in.size(), ' '); + std::transform(in.begin(), in.end(), result.begin(), do_narrow()); + return result; +} + +template +void +test_parse_error_thrown_with_message_w(bad_parse_w const (¶m)[N]) +{ + for(std::size_t i = 0 ; i < N ; ++i) + { + try { + standard_parser p; + wptree dummy; + p.parse_value(param[i].json, dummy); + BOOST_ERROR("expected exception"); + } catch (json_parser::json_parser_error& e) { + std::string message = e.message(); + if (message.find(param[i].message_substring) == + std::string::npos) + { + std::ostringstream ss; + ss << "bad error message on input '" << make_narrow(param[i].json) + << "', need: '" << param[i].message_substring + << "' but found '" << message << "'"; + BOOST_ERROR(ss.str().c_str()); + } + } } } -const bad_parse_w errors_w[] = { +const bad_parse_w +errors_w[] = { {L"", "expected value"}, {L"(", "expected value"}, @@ -911,15 +1049,45 @@ const bad_parse_w errors_w[] = { {L"{\"\":0,}", "expected key string"}, }; -template -std::size_t arraysize(T(&)[N]) { return N; } +int main() +{ + test_null_parse_result_is_input(); + test_uses_traits_from_null(); + test_null_parse_skips_bom(); + test_null_parse_result_is_input_w(); + test_null_parse_skips_bom_w(); + test_uses_traits_from_boolean_n(); + test_uses_traits_from_boolean_w(); + test_boolean_parse_result_is_input_n(booleans_n); + test_boolean_parse_result_is_input_w(booleans_w); + test_number_parse_result_is_input_n(numbers_n); + test_number_parse_result_is_input_w(numbers_w); + test_uses_traits_from_number_n(); + test_string_parsed_correctly_n(strings_n); + test_string_parsed_correctly_w(strings_w); + test_parse_error_thrown_with_message_n(errors_n); + test_parse_error_thrown_with_message_w(errors_w); + test_uses_string_callbacks(); + test_empty_array(); + test_array_with_values(); + test_array_values_get_tagged(); + test_nested_array(); + test_empty_object(); + test_object_gets_tagged(); + test_object_with_values(); + test_object_values_get_tagged(); + test_nested_object(); + test_array_in_object(); + test_object_in_array(); + test_parser_works_with_input_iterators(); + test_uses_traits_from_null_w(); + test_uses_traits_from_number_w(); + test_array_gets_tagged(); + return boost::report_errors(); +} -#define ARRAY_TEST_CASE(fn, a) \ - BOOST_PARAM_TEST_CASE(fn, (a), (a) + arraysize((a))) - -using namespace boost::unit_test; - -test_suite* init_unit_test_suite(int, char*[]) +/* +test_suite* init_unit_test_suite(int, char*[]) { master_test_suite_t& ts = boost::unit_test::framework::master_test_suite(); ts.add(ARRAY_TEST_CASE(boolean_parse_result_is_input_n, booleans_n)); @@ -933,3 +1101,4 @@ test_suite* init_unit_test_suite(int, char*[]) return 0; } +*/ \ No newline at end of file diff --git a/test/test_property_tree.cpp b/test/test_property_tree.cpp index 55ff5a8..ba1b9fb 100644 --- a/test/test_property_tree.cpp +++ b/test/test_property_tree.cpp @@ -12,7 +12,6 @@ #include #include #include -#include // If using VC, disable some warnings that trip in boost::serialization bowels #ifdef BOOST_MSVC @@ -166,7 +165,7 @@ void run_tests(Ptree* pt) test_leaks(pt); // must be a final test } -int test_main(int, char *[]) +int main(int, char *[]) { using namespace boost::property_tree; @@ -199,5 +198,5 @@ int test_main(int, char *[]) } #endif - return 0; + return boost::report_errors(); } diff --git a/test/test_property_tree.hpp b/test/test_property_tree.hpp index 4216945..bd4a764 100644 --- a/test/test_property_tree.hpp +++ b/test/test_property_tree.hpp @@ -18,42 +18,42 @@ void test_debug(PTREE *) { #if 0 // Check count - BOOST_CHECK(PTREE::debug_get_instances_count() == 0); + BOOST_TEST(PTREE::debug_get_instances_count() == 0); { // Create ptrees PTREE pt1, pt2; - BOOST_CHECK(PTREE::debug_get_instances_count() == 2); + BOOST_TEST(PTREE::debug_get_instances_count() == 2); // Create PTREE PTREE *pt3 = new PTREE; - BOOST_CHECK(PTREE::debug_get_instances_count() == 3); + BOOST_TEST(PTREE::debug_get_instances_count() == 3); // Insert pt1.push_back(std::make_pair(T("key"), *pt3)); - BOOST_CHECK(PTREE::debug_get_instances_count() == 4); + BOOST_TEST(PTREE::debug_get_instances_count() == 4); // Insert pt2.push_back(std::make_pair(T("key"), *pt3)); - BOOST_CHECK(PTREE::debug_get_instances_count() == 5); + BOOST_TEST(PTREE::debug_get_instances_count() == 5); // Clear pt1.clear(); - BOOST_CHECK(PTREE::debug_get_instances_count() == 4); + BOOST_TEST(PTREE::debug_get_instances_count() == 4); // Clear pt2.clear(); - BOOST_CHECK(PTREE::debug_get_instances_count() == 3); + BOOST_TEST(PTREE::debug_get_instances_count() == 3); // Delete delete pt3; - BOOST_CHECK(PTREE::debug_get_instances_count() == 2); + BOOST_TEST(PTREE::debug_get_instances_count() == 2); } // Check count - BOOST_CHECK(PTREE::debug_get_instances_count() == 0); + BOOST_TEST(PTREE::debug_get_instances_count() == 0); #endif } @@ -64,45 +64,45 @@ void test_constructor_destructor_assignment(PTREE *) // Test constructor from string PTREE pt1(T("data")); - BOOST_CHECK(pt1.data() == T("data")); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 1); + BOOST_TEST(pt1.data() == T("data")); + //BOOST_TEST(PTREE::debug_get_instances_count() == 1); // Do insertions PTREE &tmp1 = pt1.put(T("key1"), T("data1")); PTREE &tmp2 = pt1.put(T("key2"), T("data2")); tmp1.put(T("key3"), T("data3")); tmp2.put(T("key4"), T("data4")); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 5); + //BOOST_TEST(PTREE::debug_get_instances_count() == 5); // Make a copy using copy constructor PTREE *pt2 = new PTREE(pt1); - BOOST_CHECK(*pt2 == pt1); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 10); + BOOST_TEST(*pt2 == pt1); + //BOOST_TEST(PTREE::debug_get_instances_count() == 10); // Make a copy using = operator PTREE *pt3 = new PTREE; *pt3 = *pt2; - BOOST_CHECK(*pt3 == *pt2); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 15); + BOOST_TEST(*pt3 == *pt2); + //BOOST_TEST(PTREE::debug_get_instances_count() == 15); // Test self assignment pt1 = pt1; - BOOST_CHECK(pt1 == *pt2); - BOOST_CHECK(pt1 == *pt3); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 15); + BOOST_TEST(pt1 == *pt2); + BOOST_TEST(pt1 == *pt3); + //BOOST_TEST(PTREE::debug_get_instances_count() == 15); // Destroy delete pt2; - //BOOST_CHECK(PTREE::debug_get_instances_count() == 10); + //BOOST_TEST(PTREE::debug_get_instances_count() == 10); // Destroy delete pt3; - //BOOST_CHECK(PTREE::debug_get_instances_count() == 5); + //BOOST_TEST(PTREE::debug_get_instances_count() == 5); } // Check count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 0); } @@ -122,23 +122,23 @@ void test_insertion(PTREE *) it2->second.insert(it2->second.end(), it1->second.begin(), it1->second.end()); // Check instance count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 11); + //BOOST_TEST(PTREE::debug_get_instances_count() == 11); // Check contents - BOOST_CHECK(pt.get(T("key1"), T("")) == T("data1")); - BOOST_CHECK(pt.get(T("key2"), T("")) == T("data2")); - BOOST_CHECK(pt.get(T("key1.key3"), T("")) == T("data3")); - BOOST_CHECK(pt.get(T("key1.key4"), T("")) == T("data4")); - BOOST_CHECK(pt.get(T("key2.key3"), T("")) == T("data3")); - BOOST_CHECK(pt.get(T("key2.key4"), T("")) == T("data4")); + BOOST_TEST(pt.get(T("key1"), T("")) == T("data1")); + BOOST_TEST(pt.get(T("key2"), T("")) == T("data2")); + BOOST_TEST(pt.get(T("key1.key3"), T("")) == T("data3")); + BOOST_TEST(pt.get(T("key1.key4"), T("")) == T("data4")); + BOOST_TEST(pt.get(T("key2.key3"), T("")) == T("data3")); + BOOST_TEST(pt.get(T("key2.key4"), T("")) == T("data4")); // Check sequence PTREE::iterator it = it2; - ++it; BOOST_CHECK(it == it1); - ++it; BOOST_CHECK(it == pt.end()); + ++it; BOOST_TEST(it == it1); + ++it; BOOST_TEST(it == pt.end()); it = it4; - ++it; BOOST_CHECK(it == it3); - ++it; BOOST_CHECK(it == it1->second.end()); + ++it; BOOST_TEST(it == it3); + ++it; BOOST_TEST(it == it1->second.end()); } @@ -158,27 +158,27 @@ void test_erasing(PTREE *) it2->second.insert(it2->second.end(), it1->second.begin(), it1->second.end()); // Check instance count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 11); + //BOOST_TEST(PTREE::debug_get_instances_count() == 11); // Test range erase PTREE::iterator it = it1->second.erase(it1->second.begin(), it1->second.end()); - BOOST_CHECK(it == it1->second.end()); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 9); + BOOST_TEST(it == it1->second.end()); + //BOOST_TEST(PTREE::debug_get_instances_count() == 9); // Test single erase PTREE::size_type n = pt.erase(T("key1")); - BOOST_CHECK(n == 1); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 8); + BOOST_TEST(n == 1); + //BOOST_TEST(PTREE::debug_get_instances_count() == 8); // Test multiple erase n = it2->second.erase(T("key")); - BOOST_CHECK(n == 2); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 6); + BOOST_TEST(n == 2); + //BOOST_TEST(PTREE::debug_get_instances_count() == 6); // Test one more erase n = pt.erase(T("key2")); - BOOST_CHECK(n == 1); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 5); + BOOST_TEST(n == 1); + //BOOST_TEST(PTREE::debug_get_instances_count() == 5); } @@ -190,13 +190,13 @@ void test_clear(PTREE *) pt.push_back(std::make_pair(T("key"), PTREE(T("data")))); // Check instance count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 2); + //BOOST_TEST(PTREE::debug_get_instances_count() == 2); // Test clear pt.clear(); - BOOST_CHECK(pt.empty()); - BOOST_CHECK(pt.data().empty()); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 1); + BOOST_TEST(pt.empty()); + BOOST_TEST(pt.data().empty()); + //BOOST_TEST(PTREE::debug_get_instances_count() == 1); } @@ -215,32 +215,32 @@ void test_pushpop(PTREE *) pt.push_front(std::make_pair(T("key1"), tmp1)); // Check instance count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 9); + //BOOST_TEST(PTREE::debug_get_instances_count() == 9); // Check sequence PTREE::iterator it = pt.begin(); - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it == pt.end()); // Test pops pt.pop_back(); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 8); - BOOST_CHECK(pt.front().second.data() == T("data1")); - BOOST_CHECK(pt.back().second.data() == T("data3")); + //BOOST_TEST(PTREE::debug_get_instances_count() == 8); + BOOST_TEST(pt.front().second.data() == T("data1")); + BOOST_TEST(pt.back().second.data() == T("data3")); pt.pop_front(); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 7); - BOOST_CHECK(pt.front().second.data() == T("data2")); - BOOST_CHECK(pt.back().second.data() == T("data3")); + //BOOST_TEST(PTREE::debug_get_instances_count() == 7); + BOOST_TEST(pt.front().second.data() == T("data2")); + BOOST_TEST(pt.back().second.data() == T("data3")); pt.pop_back(); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 6); - BOOST_CHECK(pt.front().second.data() == T("data2")); - BOOST_CHECK(pt.back().second.data() == T("data2")); + //BOOST_TEST(PTREE::debug_get_instances_count() == 6); + BOOST_TEST(pt.front().second.data() == T("data2")); + BOOST_TEST(pt.back().second.data() == T("data2")); pt.pop_front(); - //BOOST_CHECK(PTREE::debug_get_instances_count() == 5); - BOOST_CHECK(pt.empty()); + //BOOST_TEST(PTREE::debug_get_instances_count() == 5); + BOOST_TEST(pt.empty()); } @@ -257,41 +257,41 @@ void test_container_iteration(PTREE *) // iterator { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it == pt.end()); } // const_iterator { PTREE::const_iterator it = pt.begin(); - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it == pt.end()); } // reverse_iterator { PTREE::reverse_iterator it = pt.rbegin(); - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it == pt.rend()); + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it == pt.rend()); } // const_reverse_iterator { PTREE::const_reverse_iterator it = pt.rbegin(); - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it == PTREE::const_reverse_iterator(pt.rend())); + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it == PTREE::const_reverse_iterator(pt.rend())); } } @@ -308,37 +308,37 @@ void test_swap(PTREE *) pt1.put(T("key1.key4"), T("")); // Check counts - //BOOST_CHECK(PTREE::debug_get_instances_count() == 6); - BOOST_CHECK(pt1.size() == 2); - BOOST_CHECK(pt1.get_child(T("key1")).size() == 2); - BOOST_CHECK(pt2.size() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 6); + BOOST_TEST(pt1.size() == 2); + BOOST_TEST(pt1.get_child(T("key1")).size() == 2); + BOOST_TEST(pt2.size() == 0); // Swap using member function pt1.swap(pt2); // Check counts - //BOOST_CHECK(PTREE::debug_get_instances_count() == 6); - BOOST_CHECK(pt2.size() == 2); - BOOST_CHECK(pt2.get_child(T("key1")).size() == 2); - BOOST_CHECK(pt1.size() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 6); + BOOST_TEST(pt2.size() == 2); + BOOST_TEST(pt2.get_child(T("key1")).size() == 2); + BOOST_TEST(pt1.size() == 0); // Swap using free function swap(pt1, pt2); // Check counts - //BOOST_CHECK(PTREE::debug_get_instances_count() == 6); - BOOST_CHECK(pt1.size() == 2); - BOOST_CHECK(pt1.get_child(T("key1")).size() == 2); - BOOST_CHECK(pt2.size() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 6); + BOOST_TEST(pt1.size() == 2); + BOOST_TEST(pt1.get_child(T("key1")).size() == 2); + BOOST_TEST(pt2.size() == 0); // Swap using std algorithm std::swap(pt1, pt2); // Check counts - //BOOST_CHECK(PTREE::debug_get_instances_count() == 6); - BOOST_CHECK(pt2.size() == 2); - BOOST_CHECK(pt2.get_child(T("key1")).size() == 2); - BOOST_CHECK(pt1.size() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 6); + BOOST_TEST(pt2.size() == 2); + BOOST_TEST(pt2.get_child(T("key1")).size() == 2); + BOOST_TEST(pt1.size() == 0); } @@ -361,20 +361,20 @@ void test_sort_reverse(PTREE *) // Check sequence { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it == pt.end()); } // Check sequence using find to check if index is ok { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it == pt.to_iterator(pt.find(T("key3")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key4")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key1")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key2")))); ++it; + BOOST_TEST(it == pt.end()); } // Sort @@ -383,20 +383,20 @@ void test_sort_reverse(PTREE *) // Check sequence { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it == pt.end()); } // Check sequence (using find to check if index is ok) { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it == pt.to_iterator(pt.find(T("key1")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key2")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key3")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key4")))); ++it; + BOOST_TEST(it == pt.end()); } // Sort reverse @@ -405,20 +405,20 @@ void test_sort_reverse(PTREE *) // Check sequence { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it->first == T("key4")); ++it; - BOOST_CHECK(it->first == T("key3")); ++it; - BOOST_CHECK(it->first == T("key2")); ++it; - BOOST_CHECK(it->first == T("key1")); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it->first == T("key4")); ++it; + BOOST_TEST(it->first == T("key3")); ++it; + BOOST_TEST(it->first == T("key2")); ++it; + BOOST_TEST(it->first == T("key1")); ++it; + BOOST_TEST(it == pt.end()); } // Check sequence (using find to check if index is ok) { PTREE::iterator it = pt.begin(); - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it; - BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it; - BOOST_CHECK(it == pt.end()); + BOOST_TEST(it == pt.to_iterator(pt.find(T("key4")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key3")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key2")))); ++it; + BOOST_TEST(it == pt.to_iterator(pt.find(T("key1")))); ++it; + BOOST_TEST(it == pt.end()); } } @@ -435,17 +435,17 @@ void test_case(PTREE *) // Check findings depending on traits type #if (NOCASE == 0) - //BOOST_CHECK(PTREE::debug_get_instances_count() == 7); - BOOST_CHECK(pt.get(T("key1"), T("")) == T("data1")); - BOOST_CHECK(pt.get(T("key2"), T("")) == T("")); - BOOST_CHECK(pt.get(T("key1.key3"), T("")) == T("")); - BOOST_CHECK(pt.get(T("KEY1.key4"), T("")) == T("data4")); + //BOOST_TEST(PTREE::debug_get_instances_count() == 7); + BOOST_TEST(pt.get(T("key1"), T("")) == T("data1")); + BOOST_TEST(pt.get(T("key2"), T("")) == T("")); + BOOST_TEST(pt.get(T("key1.key3"), T("")) == T("")); + BOOST_TEST(pt.get(T("KEY1.key4"), T("")) == T("data4")); #else - //BOOST_CHECK(PTREE::debug_get_instances_count() == 5); - BOOST_CHECK(pt.get(T("key1"), T("1")) == pt.get(T("KEY1"), T("2"))); - BOOST_CHECK(pt.get(T("key2"), T("1")) == pt.get(T("KEY2"), T("2"))); - BOOST_CHECK(pt.get(T("key1.key3"), T("1")) == pt.get(T("KEY1.KEY3"), T("2"))); - BOOST_CHECK(pt.get(T("key1.key4"), T("1")) == pt.get(T("KEY1.KEY4"), T("2"))); + //BOOST_TEST(PTREE::debug_get_instances_count() == 5); + BOOST_TEST(pt.get(T("key1"), T("1")) == pt.get(T("KEY1"), T("2"))); + BOOST_TEST(pt.get(T("key2"), T("1")) == pt.get(T("KEY2"), T("2"))); + BOOST_TEST(pt.get(T("key1.key3"), T("1")) == pt.get(T("KEY1.KEY3"), T("2"))); + BOOST_TEST(pt.get(T("key1.key4"), T("1")) == pt.get(T("KEY1.KEY4"), T("2"))); #endif // Do more insertions @@ -454,19 +454,19 @@ void test_case(PTREE *) // Test counts #if (NOCASE == 0) - BOOST_CHECK(pt.count(T("key1")) == 3); - BOOST_CHECK(pt.count(T("KEY1")) == 1); - BOOST_CHECK(pt.count(T("key2")) == 0); - BOOST_CHECK(pt.count(T("KEY2")) == 1); - BOOST_CHECK(pt.count(T("key3")) == 0); - BOOST_CHECK(pt.count(T("KEY3")) == 0); + BOOST_TEST(pt.count(T("key1")) == 3); + BOOST_TEST(pt.count(T("KEY1")) == 1); + BOOST_TEST(pt.count(T("key2")) == 0); + BOOST_TEST(pt.count(T("KEY2")) == 1); + BOOST_TEST(pt.count(T("key3")) == 0); + BOOST_TEST(pt.count(T("KEY3")) == 0); #else - BOOST_CHECK(pt.count(T("key1")) == 3); - BOOST_CHECK(pt.count(T("KEY1")) == 3); - BOOST_CHECK(pt.count(T("key2")) == 1); - BOOST_CHECK(pt.count(T("KEY2")) == 1); - BOOST_CHECK(pt.count(T("key3")) == 0); - BOOST_CHECK(pt.count(T("KEY3")) == 0); + BOOST_TEST(pt.count(T("key1")) == 3); + BOOST_TEST(pt.count(T("KEY1")) == 3); + BOOST_TEST(pt.count(T("key2")) == 1); + BOOST_TEST(pt.count(T("KEY2")) == 1); + BOOST_TEST(pt.count(T("key3")) == 0); + BOOST_TEST(pt.count(T("KEY3")) == 0); #endif } @@ -485,10 +485,10 @@ void test_comparison(PTREE *) { PTREE pt1(pt_orig); PTREE pt2(pt_orig); - BOOST_CHECK(pt1 == pt2); - BOOST_CHECK(pt2 == pt1); - BOOST_CHECK(!(pt1 != pt2)); - BOOST_CHECK(!(pt2 != pt1)); + BOOST_TEST(pt1 == pt2); + BOOST_TEST(pt2 == pt1); + BOOST_TEST(!(pt1 != pt2)); + BOOST_TEST(!(pt2 != pt1)); } // Test originals with modified case @@ -498,10 +498,10 @@ void test_comparison(PTREE *) PTREE pt2(pt_orig); pt1.pop_back(); pt1.put(T("KEY2"), T("data4")); - BOOST_CHECK(pt1 == pt2); - BOOST_CHECK(pt2 == pt1); - BOOST_CHECK(!(pt1 != pt2)); - BOOST_CHECK(!(pt2 != pt1)); + BOOST_TEST(pt1 == pt2); + BOOST_TEST(pt2 == pt1); + BOOST_TEST(!(pt1 != pt2)); + BOOST_TEST(!(pt2 != pt1)); } #endif @@ -511,10 +511,10 @@ void test_comparison(PTREE *) PTREE pt2(pt_orig); pt1.put(T("key1.key5"), T(".")); pt2.put(T("key1.key5"), T(".")); - BOOST_CHECK(pt1 == pt2); - BOOST_CHECK(pt2 == pt1); - BOOST_CHECK(!(pt1 != pt2)); - BOOST_CHECK(!(pt2 != pt1)); + BOOST_TEST(pt1 == pt2); + BOOST_TEST(pt2 == pt1); + BOOST_TEST(!(pt1 != pt2)); + BOOST_TEST(!(pt2 != pt1)); } // Test modified copies (modified root data) @@ -523,10 +523,10 @@ void test_comparison(PTREE *) PTREE pt2(pt_orig); pt1.data() = T("a"); pt2.data() = T("b"); - BOOST_CHECK(!(pt1 == pt2)); - BOOST_CHECK(!(pt2 == pt1)); - BOOST_CHECK(pt1 != pt2); - BOOST_CHECK(pt2 != pt1); + BOOST_TEST(!(pt1 == pt2)); + BOOST_TEST(!(pt2 == pt1)); + BOOST_TEST(pt1 != pt2); + BOOST_TEST(pt2 != pt1); } // Test modified copies (added subkeys with different data) @@ -535,10 +535,10 @@ void test_comparison(PTREE *) PTREE pt2(pt_orig); pt1.put(T("key1.key5"), T("a")); pt2.put(T("key1.key5"), T("b")); - BOOST_CHECK(!(pt1 == pt2)); - BOOST_CHECK(!(pt2 == pt1)); - BOOST_CHECK(pt1 != pt2); - BOOST_CHECK(pt2 != pt1); + BOOST_TEST(!(pt1 == pt2)); + BOOST_TEST(!(pt2 == pt1)); + BOOST_TEST(pt1 != pt2); + BOOST_TEST(pt2 != pt1); } // Test modified copies (added subkeys with different keys) @@ -547,10 +547,10 @@ void test_comparison(PTREE *) PTREE pt2(pt_orig); pt1.put(T("key1.key5"), T("")); pt2.put(T("key1.key6"), T("")); - BOOST_CHECK(!(pt1 == pt2)); - BOOST_CHECK(!(pt2 == pt1)); - BOOST_CHECK(pt1 != pt2); - BOOST_CHECK(pt2 != pt1); + BOOST_TEST(!(pt1 == pt2)); + BOOST_TEST(!(pt2 == pt1)); + BOOST_TEST(pt1 != pt2); + BOOST_TEST(pt2 != pt1); } // Test modified copies (added subkey to only one copy) @@ -558,10 +558,10 @@ void test_comparison(PTREE *) PTREE pt1(pt_orig); PTREE pt2(pt_orig); pt1.put(T("key1.key5"), T("")); - BOOST_CHECK(!(pt1 == pt2)); - BOOST_CHECK(!(pt2 == pt1)); - BOOST_CHECK(pt1 != pt2); - BOOST_CHECK(pt2 != pt1); + BOOST_TEST(!(pt1 == pt2)); + BOOST_TEST(!(pt2 == pt1)); + BOOST_TEST(pt1 != pt2); + BOOST_TEST(pt2 != pt1); } } @@ -575,8 +575,8 @@ void test_front_back(PTREE *) pt.put(T("key2"), T("")); // Check front and back - BOOST_CHECK(pt.front().first == T("key1")); - BOOST_CHECK(pt.back().first == T("key2")); + BOOST_TEST(pt.front().first == T("key1")); + BOOST_TEST(pt.back().first == T("key2")); } @@ -605,49 +605,49 @@ void test_get_put(PTREE *) PTREE &pt6 = pt.put(T("k5.k.k.k.t"), true); // Check instances count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 17); + //BOOST_TEST(PTREE::debug_get_instances_count() == 17); // Check if const char * version returns std::string - BOOST_CHECK(typeid(pt.get_value(T(""))) == typeid(str_t)); + BOOST_TEST(typeid(pt.get_value(T(""))) == typeid(str_t)); // Do extractions via get (throwing version) - BOOST_CHECK(pt.get(T("k1")) == 1); - BOOST_CHECK(pt.get(T("k1")) == 1); - BOOST_CHECK(pt.get(T("k2.k")) == 2.5); - BOOST_CHECK(pt.get(T("k2.k")) == 2.5f); - BOOST_CHECK(pt.get(T("k3.k.k")) == str_t(T("ala ma kota"))); - BOOST_CHECK(pt.get(T("k4.k.k.k")) == CHTYPE('c')); - BOOST_CHECK(pt.get(T("k5.k.k.k.f")) == false); - BOOST_CHECK(pt.get(T("k5.k.k.k.t")) == true); + BOOST_TEST(pt.get(T("k1")) == 1); + BOOST_TEST(pt.get(T("k1")) == 1); + BOOST_TEST(pt.get(T("k2.k")) == 2.5); + BOOST_TEST(pt.get(T("k2.k")) == 2.5f); + BOOST_TEST(pt.get(T("k3.k.k")) == str_t(T("ala ma kota"))); + BOOST_TEST(pt.get(T("k4.k.k.k")) == CHTYPE('c')); + BOOST_TEST(pt.get(T("k5.k.k.k.f")) == false); + BOOST_TEST(pt.get(T("k5.k.k.k.t")) == true); // Do extractions via get (default value version) - BOOST_CHECK(pt.get(T("k1"), 0) == 1); - BOOST_CHECK(pt.get(T("k1"), 0L) == 1); - BOOST_CHECK(pt.get(T("k2.k"), 0.0) == 2.5); - BOOST_CHECK(pt.get(T("k2.k"), 0.0f) == 2.5f); - BOOST_CHECK(pt.get(T("k3.k.k"), str_t()) == str_t(T("ala ma kota"))); - BOOST_CHECK(pt.get(T("k3.k.k"), T("")) == T("ala ma kota")); - BOOST_CHECK(pt.get(T("k4.k.k.k"), CHTYPE('\0')) == CHTYPE('c')); - BOOST_CHECK(pt.get(T("k5.k.k.k.f"), true) == false); - BOOST_CHECK(pt.get(T("k5.k.k.k.t"), false) == true); + BOOST_TEST(pt.get(T("k1"), 0) == 1); + BOOST_TEST(pt.get(T("k1"), 0L) == 1); + BOOST_TEST(pt.get(T("k2.k"), 0.0) == 2.5); + BOOST_TEST(pt.get(T("k2.k"), 0.0f) == 2.5f); + BOOST_TEST(pt.get(T("k3.k.k"), str_t()) == str_t(T("ala ma kota"))); + BOOST_TEST(pt.get(T("k3.k.k"), T("")) == T("ala ma kota")); + BOOST_TEST(pt.get(T("k4.k.k.k"), CHTYPE('\0')) == CHTYPE('c')); + BOOST_TEST(pt.get(T("k5.k.k.k.f"), true) == false); + BOOST_TEST(pt.get(T("k5.k.k.k.t"), false) == true); // Do extractions via get (optional version) opt_int = pt.get_optional(T("k1")); - BOOST_CHECK(opt_int && *opt_int == 1); + BOOST_TEST(opt_int && *opt_int == 1); opt_long = pt.get_optional(T("k1")); - BOOST_CHECK(opt_long && *opt_long == 1); + BOOST_TEST(opt_long && *opt_long == 1); opt_double = pt.get_optional(T("k2.k")); - BOOST_CHECK(opt_double && *opt_double == 2.5); + BOOST_TEST(opt_double && *opt_double == 2.5); opt_float = pt.get_optional(T("k2.k")); - BOOST_CHECK(opt_float && *opt_float == 2.5f); + BOOST_TEST(opt_float && *opt_float == 2.5f); opt_string = pt.get_optional(T("k3.k.k")); - BOOST_CHECK(opt_string && *opt_string == str_t(T("ala ma kota"))); + BOOST_TEST(opt_string && *opt_string == str_t(T("ala ma kota"))); opt_char = pt.get_optional(T("k4.k.k.k")); - BOOST_CHECK(opt_char && *opt_char == CHTYPE('c')); + BOOST_TEST(opt_char && *opt_char == CHTYPE('c')); opt_bool = pt.get_optional(T("k5.k.k.k.f")); - BOOST_CHECK(opt_bool && *opt_bool == false); + BOOST_TEST(opt_bool && *opt_bool == false); opt_bool = pt.get_optional(T("k5.k.k.k.t")); - BOOST_CHECK(opt_bool && *opt_bool == true); + BOOST_TEST(opt_bool && *opt_bool == true); // Do insertions via put_value pt1.put_value(short(1)); @@ -658,43 +658,43 @@ void test_get_put(PTREE *) pt6.put_value(true); // Do extractions via get_value (throwing version) - BOOST_CHECK(pt1.get_value() == 1); - BOOST_CHECK(pt1.get_value() == 1); - BOOST_CHECK(pt2.get_value() == 2.5); - BOOST_CHECK(pt2.get_value() == 2.5f); - BOOST_CHECK(pt3.get_value() == str_t(T("ala ma kota"))); - BOOST_CHECK(pt4.get_value() == CHTYPE('c')); - BOOST_CHECK(pt5.get_value() == false); - BOOST_CHECK(pt6.get_value() == true); + BOOST_TEST(pt1.get_value() == 1); + BOOST_TEST(pt1.get_value() == 1); + BOOST_TEST(pt2.get_value() == 2.5); + BOOST_TEST(pt2.get_value() == 2.5f); + BOOST_TEST(pt3.get_value() == str_t(T("ala ma kota"))); + BOOST_TEST(pt4.get_value() == CHTYPE('c')); + BOOST_TEST(pt5.get_value() == false); + BOOST_TEST(pt6.get_value() == true); // Do extractions via get_value (default value version) - BOOST_CHECK(pt1.get_value(0) == 1); - BOOST_CHECK(pt1.get_value(0L) == 1); - BOOST_CHECK(pt2.get_value(0.0) == 2.5); - BOOST_CHECK(pt2.get_value(0.0f) == 2.5f); - BOOST_CHECK(pt3.get_value(str_t()) == str_t(T("ala ma kota"))); - BOOST_CHECK(pt3.get_value(T("")) == T("ala ma kota")); - BOOST_CHECK(pt4.get_value(CHTYPE('\0')) == CHTYPE('c')); - BOOST_CHECK(pt5.get_value(true) == false); - BOOST_CHECK(pt6.get_value(false) == true); + BOOST_TEST(pt1.get_value(0) == 1); + BOOST_TEST(pt1.get_value(0L) == 1); + BOOST_TEST(pt2.get_value(0.0) == 2.5); + BOOST_TEST(pt2.get_value(0.0f) == 2.5f); + BOOST_TEST(pt3.get_value(str_t()) == str_t(T("ala ma kota"))); + BOOST_TEST(pt3.get_value(T("")) == T("ala ma kota")); + BOOST_TEST(pt4.get_value(CHTYPE('\0')) == CHTYPE('c')); + BOOST_TEST(pt5.get_value(true) == false); + BOOST_TEST(pt6.get_value(false) == true); // Do extractions via get_value (optional version) opt_int = pt1.get_value_optional(); - BOOST_CHECK(opt_int && *opt_int == 1); + BOOST_TEST(opt_int && *opt_int == 1); opt_long = pt1.get_value_optional(); - BOOST_CHECK(opt_long && *opt_long == 1); + BOOST_TEST(opt_long && *opt_long == 1); opt_double = pt2.get_value_optional(); - BOOST_CHECK(opt_double && *opt_double == 2.5); + BOOST_TEST(opt_double && *opt_double == 2.5); opt_float = pt2.get_value_optional(); - BOOST_CHECK(opt_float && *opt_float == 2.5f); + BOOST_TEST(opt_float && *opt_float == 2.5f); opt_string = pt3.get_value_optional(); - BOOST_CHECK(opt_string && *opt_string == str_t(T("ala ma kota"))); + BOOST_TEST(opt_string && *opt_string == str_t(T("ala ma kota"))); opt_char = pt4.get_value_optional(); - BOOST_CHECK(opt_char && *opt_char == CHTYPE('c')); + BOOST_TEST(opt_char && *opt_char == CHTYPE('c')); opt_bool = pt5.get_value_optional(); - BOOST_CHECK(opt_bool && *opt_bool == false); + BOOST_TEST(opt_bool && *opt_bool == false); opt_bool = pt6.get_value_optional(); - BOOST_CHECK(opt_bool && *opt_bool == true); + BOOST_TEST(opt_bool && *opt_bool == true); // Do incorrect extractions (throwing version) try @@ -719,51 +719,51 @@ void test_get_put(PTREE *) } // Do incorrect extractions (default value version) - BOOST_CHECK(pt.get(T("k2.k"), -7) == -7); - BOOST_CHECK(pt.get(T("k3.k.k"), -7) == -7); - BOOST_CHECK(pt.get(T("k4.k.k.k"), -7) == -7); + BOOST_TEST(pt.get(T("k2.k"), -7) == -7); + BOOST_TEST(pt.get(T("k3.k.k"), -7) == -7); + BOOST_TEST(pt.get(T("k4.k.k.k"), -7) == -7); // Do incorrect extractions (optional version) - BOOST_CHECK(!pt.get_optional(T("k2.k"))); - BOOST_CHECK(!pt.get_optional(T("k3.k.k"))); - BOOST_CHECK(!pt.get_optional(T("k4.k.k.k"))); + BOOST_TEST(!pt.get_optional(T("k2.k"))); + BOOST_TEST(!pt.get_optional(T("k3.k.k"))); + BOOST_TEST(!pt.get_optional(T("k4.k.k.k"))); // Test multiple puts with the same key { PTREE pt; pt.put(T("key"), 1); - BOOST_CHECK(pt.get(T("key")) == 1); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.get(T("key")) == 1); + BOOST_TEST(pt.size() == 1); pt.put(T("key"), 2); - BOOST_CHECK(pt.get(T("key")) == 2); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.get(T("key")) == 2); + BOOST_TEST(pt.size() == 1); pt.put(T("key.key.key"), 1); PTREE &child = pt.get_child(T("key.key")); - BOOST_CHECK(pt.get(T("key.key.key")) == 1); - BOOST_CHECK(child.size() == 1); - BOOST_CHECK(child.count(T("key")) == 1); + BOOST_TEST(pt.get(T("key.key.key")) == 1); + BOOST_TEST(child.size() == 1); + BOOST_TEST(child.count(T("key")) == 1); pt.put(T("key.key.key"), 2); - BOOST_CHECK(pt.get(T("key.key.key")) == 2); - BOOST_CHECK(child.size() == 1); - BOOST_CHECK(child.count(T("key")) == 1); + BOOST_TEST(pt.get(T("key.key.key")) == 2); + BOOST_TEST(child.size() == 1); + BOOST_TEST(child.count(T("key")) == 1); } // Test multiple puts with the same key { PTREE pt; pt.put(T("key"), 1); - BOOST_CHECK(pt.get(T("key")) == 1); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.get(T("key")) == 1); + BOOST_TEST(pt.size() == 1); pt.put(T("key"), 2); - BOOST_CHECK(pt.get(T("key")) == 2); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.get(T("key")) == 2); + BOOST_TEST(pt.size() == 1); pt.put(T("key.key.key"), 1); PTREE &child = pt.get_child(T("key.key")); - BOOST_CHECK(child.size() == 1); - BOOST_CHECK(child.count(T("key")) == 1); + BOOST_TEST(child.size() == 1); + BOOST_TEST(child.count(T("key")) == 1); pt.add(T("key.key.key"), 2); - BOOST_CHECK(child.size() == 2); - BOOST_CHECK(child.count(T("key")) == 2); + BOOST_TEST(child.size() == 2); + BOOST_TEST(child.count(T("key")) == 2); } // Test that put does not destroy children @@ -771,11 +771,11 @@ void test_get_put(PTREE *) PTREE pt; pt.put(T("key1"), 1); pt.put(T("key1.key2"), 2); - BOOST_CHECK(pt.get(T("key1"), 0) == 1); - BOOST_CHECK(pt.get(T("key1.key2"), 0) == 2); + BOOST_TEST(pt.get(T("key1"), 0) == 1); + BOOST_TEST(pt.get(T("key1.key2"), 0) == 2); pt.put(T("key1"), 2); - BOOST_CHECK(pt.get(T("key1"), 0) == 2); - BOOST_CHECK(pt.get(T("key1.key2"), 0) == 2); + BOOST_TEST(pt.get(T("key1"), 0) == 2); + BOOST_TEST(pt.get(T("key1.key2"), 0) == 2); } // Test that get of single character that is whitespace works @@ -783,14 +783,14 @@ void test_get_put(PTREE *) PTREE pt; pt.put_value(T(' ')); CHTYPE ch = pt.get_value(); - BOOST_CHECK(ch == T(' ')); + BOOST_TEST(ch == T(' ')); } // Test that get of non-char value with trailing and leading whitespace works { PTREE pt; pt.put_value(T(" \t\n99 \t\n")); - BOOST_CHECK(pt.get_value(0) == 99); + BOOST_TEST(pt.get_value(0) == 99); } } @@ -810,44 +810,44 @@ void test_get_child_put_child(PTREE *) const PTREE &cpt1 = pt1, &cpt2 = pt2; // Do correct extractions via get_child (throwing version) - BOOST_CHECK(pt1.get_child(T("k1")).empty()); - BOOST_CHECK(pt1.get_child(T("k2.k")).empty()); - BOOST_CHECK(pt2.get_child(T("k1")) == pt); - BOOST_CHECK(pt2.get_child(T("k2.k")) == pt); - BOOST_CHECK(cpt1.get_child(T("k1")).empty()); - BOOST_CHECK(cpt1.get_child(T("k2.k")).empty()); - BOOST_CHECK(cpt2.get_child(T("k1")) == pt); - BOOST_CHECK(cpt2.get_child(T("k2.k")) == pt); + BOOST_TEST(pt1.get_child(T("k1")).empty()); + BOOST_TEST(pt1.get_child(T("k2.k")).empty()); + BOOST_TEST(pt2.get_child(T("k1")) == pt); + BOOST_TEST(pt2.get_child(T("k2.k")) == pt); + BOOST_TEST(cpt1.get_child(T("k1")).empty()); + BOOST_TEST(cpt1.get_child(T("k2.k")).empty()); + BOOST_TEST(cpt2.get_child(T("k1")) == pt); + BOOST_TEST(cpt2.get_child(T("k2.k")) == pt); // Do correct extractions via get_child (default value version) - BOOST_CHECK(pt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def"))); - BOOST_CHECK(pt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def"))); - BOOST_CHECK(pt2.get_child(T("k1"), PTREE(T("def"))) == pt); - BOOST_CHECK(pt2.get_child(T("k2.k"), PTREE(T("def"))) == pt); - BOOST_CHECK(cpt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def"))); - BOOST_CHECK(cpt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def"))); - BOOST_CHECK(cpt2.get_child(T("k1"), PTREE(T("def"))) == pt); - BOOST_CHECK(cpt2.get_child(T("k2.k"), PTREE(T("def"))) == pt); + BOOST_TEST(pt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def"))); + BOOST_TEST(pt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def"))); + BOOST_TEST(pt2.get_child(T("k1"), PTREE(T("def"))) == pt); + BOOST_TEST(pt2.get_child(T("k2.k"), PTREE(T("def"))) == pt); + BOOST_TEST(cpt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def"))); + BOOST_TEST(cpt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def"))); + BOOST_TEST(cpt2.get_child(T("k1"), PTREE(T("def"))) == pt); + BOOST_TEST(cpt2.get_child(T("k2.k"), PTREE(T("def"))) == pt); // Do correct extractions via get_child (optional version) boost::optional opt; boost::optional copt; opt = pt1.get_child_optional(T("k1")); - BOOST_CHECK(opt); + BOOST_TEST(opt); opt = pt1.get_child_optional(T("k2.k")); - BOOST_CHECK(opt); + BOOST_TEST(opt); opt = pt2.get_child_optional(T("k1")); - BOOST_CHECK(opt && *opt == pt); + BOOST_TEST(opt && *opt == pt); opt = pt2.get_child_optional(T("k2.k")); - BOOST_CHECK(opt && *opt == pt); + BOOST_TEST(opt && *opt == pt); copt = cpt1.get_child_optional(T("k1")); - BOOST_CHECK(copt); + BOOST_TEST(copt); copt = cpt1.get_child_optional(T("k2.k")); - BOOST_CHECK(copt); + BOOST_TEST(copt); copt = cpt2.get_child_optional(T("k1")); - BOOST_CHECK(copt && *copt == pt); + BOOST_TEST(copt && *copt == pt); copt = cpt2.get_child_optional(T("k2.k")); - BOOST_CHECK(copt && *copt == pt); + BOOST_TEST(copt && *copt == pt); // Do incorrect extractions via get_child (throwing version) try @@ -862,42 +862,42 @@ void test_get_child_put_child(PTREE *) } // Do incorrect extractions via get_child (default value version) - BOOST_CHECK(&pt.get_child(T("k2.k.bogus.path"), pt3) == &pt3); + BOOST_TEST(&pt.get_child(T("k2.k.bogus.path"), pt3) == &pt3); // Do incorrect extractions via get_child (optional version) - BOOST_CHECK(!pt.get_child_optional(T("k2.k.bogus.path"))); + BOOST_TEST(!pt.get_child_optional(T("k2.k.bogus.path"))); // Test multiple puts with the same key { PTREE pt, tmp1(T("data1")), tmp2(T("data2")); pt.put_child(T("key"), tmp1); - BOOST_CHECK(pt.get_child(T("key")) == tmp1); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.get_child(T("key")) == tmp1); + BOOST_TEST(pt.size() == 1); pt.put_child(T("key"), tmp2); - BOOST_CHECK(pt.get_child(T("key")) == tmp2); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.get_child(T("key")) == tmp2); + BOOST_TEST(pt.size() == 1); pt.put_child(T("key.key.key"), tmp1); PTREE &child = pt.get_child(T("key.key")); - BOOST_CHECK(child.size() == 1); + BOOST_TEST(child.size() == 1); pt.put_child(T("key.key.key"), tmp2); - BOOST_CHECK(child.size() == 1); + BOOST_TEST(child.size() == 1); } // Test multiple adds with the same key { PTREE pt, tmp1(T("data1")), tmp2(T("data2")); pt.add_child(T("key"), tmp1); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.size() == 1); pt.add_child(T("key"), tmp2); - BOOST_CHECK(pt.size() == 2); - BOOST_CHECK(pt.count(T("key")) == 2); + BOOST_TEST(pt.size() == 2); + BOOST_TEST(pt.count(T("key")) == 2); pt.add_child(T("key.key.key"), tmp1); PTREE &child = pt.get_child(T("key.key")); - BOOST_CHECK(child.size() == 1); - BOOST_CHECK(child.count(T("key")) == 1); + BOOST_TEST(child.size() == 1); + BOOST_TEST(child.count(T("key")) == 1); pt.add_child(T("key.key.key"), tmp2); - BOOST_CHECK(child.size() == 2); - BOOST_CHECK(child.count(T("key")) == 2); + BOOST_TEST(child.size() == 2); + BOOST_TEST(child.count(T("key")) == 2); } // Test assigning child to tree @@ -905,8 +905,8 @@ void test_get_child_put_child(PTREE *) PTREE pt; pt.put(T("foo.bar"), T("baz")); pt = pt.get_child(T("foo")); - BOOST_CHECK(pt.size() == 1); - BOOST_CHECK(pt.get< std::basic_string >(T("bar")) == T("baz")); + BOOST_TEST(pt.size() == 1); + BOOST_TEST(pt.get< std::basic_string >(T("bar")) == T("baz")); } } @@ -921,9 +921,9 @@ void test_equal_range(PTREE *) pt.add_child(T("k1"), PTREE()); pt.add_child(T("k2"), PTREE()); - BOOST_CHECK(boost::distance(pt.equal_range(T("k1"))) == 3); - BOOST_CHECK(boost::distance(pt.equal_range(T("k2"))) == 2); - BOOST_CHECK(boost::distance(pt.equal_range(T("k3"))) == 1); + BOOST_TEST(boost::distance(pt.equal_range(T("k1"))) == 3); + BOOST_TEST(boost::distance(pt.equal_range(T("k2"))) == 2); + BOOST_TEST(boost::distance(pt.equal_range(T("k3"))) == 1); } void test_path_separator(PTREE *) @@ -932,7 +932,7 @@ void test_path_separator(PTREE *) typedef PTREE::path_type path; // Check instances count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 0); // Do insertions PTREE pt; @@ -944,21 +944,21 @@ void test_path_separator(PTREE *) pt.put(path(T("key6/key/key"), CHTYPE('/')), T("6")); // Check instances count - //BOOST_CHECK(PTREE::debug_get_instances_count() == 13); + //BOOST_TEST(PTREE::debug_get_instances_count() == 13); // Do correct extractions - BOOST_CHECK(pt.get(T("key1"), 0) == 1); - BOOST_CHECK(pt.get(T("key2.key"), 0) == 2); - BOOST_CHECK(pt.get(T("key3.key.key"), 0) == 3); - BOOST_CHECK(pt.get(path(T("key4"), CHTYPE('/')), 0) == 4); - BOOST_CHECK(pt.get(path(T("key5/key"), CHTYPE('/')), 0) == 5); - BOOST_CHECK(pt.get(path(T("key6/key/key"), CHTYPE('/')), 0) == 6); + BOOST_TEST(pt.get(T("key1"), 0) == 1); + BOOST_TEST(pt.get(T("key2.key"), 0) == 2); + BOOST_TEST(pt.get(T("key3.key.key"), 0) == 3); + BOOST_TEST(pt.get(path(T("key4"), CHTYPE('/')), 0) == 4); + BOOST_TEST(pt.get(path(T("key5/key"), CHTYPE('/')), 0) == 5); + BOOST_TEST(pt.get(path(T("key6/key/key"), CHTYPE('/')), 0) == 6); // Do incorrect extractions - BOOST_CHECK(pt.get(T("key2/key"), 0) == 0); - BOOST_CHECK(pt.get(T("key3/key/key"), 0) == 0); - BOOST_CHECK(pt.get(path(T("key5.key"), CHTYPE('/')), 0) == 0); - BOOST_CHECK(pt.get(path(T("key6.key.key"), CHTYPE('/')), 0) == 0); + BOOST_TEST(pt.get(T("key2/key"), 0) == 0); + BOOST_TEST(pt.get(T("key3/key/key"), 0) == 0); + BOOST_TEST(pt.get(path(T("key5.key"), CHTYPE('/')), 0) == 0); + BOOST_TEST(pt.get(path(T("key6.key.key"), CHTYPE('/')), 0) == 0); } @@ -975,14 +975,14 @@ void test_path(PTREE *) { path p; p /= T("key1"); p /= T("key2"); p /= T("key3"); - BOOST_CHECK(pt.get(p, 0) == 1); + BOOST_TEST(pt.get(p, 0) == 1); } // Test operator /= { path p(T("key1")); p /= T("key2.key3"); - BOOST_CHECK(pt.get(p, 0) == 1); + BOOST_TEST(pt.get(p, 0) == 1); } // Test operator /= @@ -992,19 +992,19 @@ void test_path(PTREE *) path p2(T("key3")); p /= p1; p /= p2; - BOOST_CHECK(pt.get(p, 0) == 1); + BOOST_TEST(pt.get(p, 0) == 1); } // Test operator / { path p = path(T("key1")) / T("key2.key3"); - BOOST_CHECK(pt.get(p, 0) == 1); + BOOST_TEST(pt.get(p, 0) == 1); } // Test operator / { path p = T("key1.key2") / path(T("key3")); - BOOST_CHECK(pt.get(p, 0) == 1); + BOOST_TEST(pt.get(p, 0) == 1); } } @@ -1027,7 +1027,7 @@ void test_precision(PTREE *) real error = abs(pi - pi2) * pow(real(numeric_limits::radix), real(numeric_limits::digits)); - BOOST_CHECK(error < 100); + BOOST_TEST(error < 100); } @@ -1051,8 +1051,8 @@ void test_locale(PTREE *) pt.put(T("french"), 1.234, translator(loc_french)); // Test contents - BOOST_CHECK(pt.get(T("english")) == T("1.234")); - BOOST_CHECK(pt.get(T("french")) == T("1,234")); + BOOST_TEST(pt.get(T("english")) == T("1.234")); + BOOST_TEST(pt.get(T("french")) == T("1,234")); } catch (boost::property_tree::ptree_error &) @@ -1081,20 +1081,20 @@ void test_custom_data_type(PTREE *) // Put/get int value pt.put(T("int value"), 3); int int_value = pt.get(T("int value")); - BOOST_CHECK(int_value == 3); + BOOST_TEST(int_value == 3); // Put/get string value pt.put >(T("string value"), T("foo bar")); std::basic_string string_value = pt.get >(T("string value")); - BOOST_CHECK(string_value == T("foo bar")); + BOOST_TEST(string_value == T("foo bar")); // Put/get list value int list_data[] = { 1, 2, 3, 4, 5 }; pt.put >(T("list value"), std::list(list_data, list_data + sizeof(list_data) / sizeof(*list_data))); std::list list_value = pt.get >(T("list value")); - BOOST_CHECK(list_value.size() == 5); - BOOST_CHECK(list_value.front() == 1); - BOOST_CHECK(list_value.back() == 5); + BOOST_TEST(list_value.size() == 5); + BOOST_TEST(list_value.front() == 1); + BOOST_TEST(list_value.back() == 5); } @@ -1102,19 +1102,19 @@ void test_empty_size_max_size(PTREE *) { PTREE pt; - BOOST_CHECK(pt.max_size()); - BOOST_CHECK(pt.empty()); - BOOST_CHECK(pt.size() == 0); + BOOST_TEST(pt.max_size()); + BOOST_TEST(pt.empty()); + BOOST_TEST(pt.size() == 0); pt.put(T("test1"), 1); - BOOST_CHECK(pt.max_size()); - BOOST_CHECK(!pt.empty()); - BOOST_CHECK(pt.size() == 1); + BOOST_TEST(pt.max_size()); + BOOST_TEST(!pt.empty()); + BOOST_TEST(pt.size() == 1); pt.put(T("test2"), 2); - BOOST_CHECK(pt.max_size()); - BOOST_CHECK(!pt.empty()); - BOOST_CHECK(pt.size() == 2); + BOOST_TEST(pt.max_size()); + BOOST_TEST(!pt.empty()); + BOOST_TEST(pt.size() == 2); } @@ -1131,7 +1131,7 @@ void test_ptree_bad_path(PTREE *) { PTREE::path_type path = e.path(); std::string what = e.what(); - BOOST_CHECK(what.find("non.existent.path") != std::string::npos); + BOOST_TEST(what.find("non.existent.path") != std::string::npos); return; } @@ -1155,7 +1155,7 @@ void test_ptree_bad_data(PTREE *) std::string what = e.what(); // FIXME: Bring back what translation or make it more clear that it // doesn't work. - //BOOST_CHECK(what.find("non convertible to int") != std::string::npos); + //BOOST_TEST(what.find("non convertible to int") != std::string::npos); return; } @@ -1187,7 +1187,7 @@ void test_serialization(PTREE *) boost::archive::text_iarchive ia(stream); PTREE pt2; ia & pt2; - BOOST_CHECK(pt1 == pt2); + BOOST_TEST(pt1 == pt2); } // Test binary archives @@ -1198,18 +1198,26 @@ void test_serialization(PTREE *) boost::archive::binary_iarchive ia(stream); PTREE pt2; ia & pt2; - BOOST_CHECK(pt1 == pt2); + BOOST_TEST(pt1 == pt2); } // Test XML archives { std::stringstream stream; - boost::archive::xml_oarchive oa(stream); - oa & boost::serialization::make_nvp("pt", pt1); - boost::archive::xml_iarchive ia(stream); + + { + boost::archive::xml_oarchive oa(stream); + oa & boost::serialization::make_nvp("pt", pt1); + } + PTREE pt2; - ia & boost::serialization::make_nvp("pt", pt2); - BOOST_CHECK(pt1 == pt2); + + { + boost::archive::xml_iarchive ia(stream); + ia & boost::serialization::make_nvp("pt", pt2); + } + + BOOST_TEST(pt1 == pt2); } } @@ -1231,17 +1239,17 @@ void test_bool(PTREE *) // Test false for (PTREE::iterator it = pt.get_child(T("bool.false")).begin(); it != pt.get_child(T("bool.false")).end(); ++it) - BOOST_CHECK(it->second.get_value() == false); + BOOST_TEST(it->second.get_value() == false); // Test true for (PTREE::iterator it = pt.get_child(T("bool.true")).begin(); it != pt.get_child(T("bool.true")).end(); ++it) - BOOST_CHECK(it->second.get_value() == true); + BOOST_TEST(it->second.get_value() == true); // Test invalid for (PTREE::iterator it = pt.get_child(T("bool.invalid")).begin(); it != pt.get_child(T("bool.invalid")).end(); ++it) { - BOOST_CHECK(it->second.get_value(false) == false); - BOOST_CHECK(it->second.get_value(true) == true); + BOOST_TEST(it->second.get_value(false) == false); + BOOST_TEST(it->second.get_value(true) == true); } } @@ -1271,23 +1279,23 @@ void test_char(PTREE *) // Verify normal conversions #if WIDECHAR == 0 - BOOST_CHECK(pt.get(T("char")) == 'A'); + BOOST_TEST(pt.get(T("char")) == 'A'); #endif - BOOST_CHECK(pt.get(T("signed char")) == static_cast('A')); - BOOST_CHECK(pt.get(T("unsigned char")) == static_cast('A')); + BOOST_TEST(pt.get(T("signed char")) == static_cast('A')); + BOOST_TEST(pt.get(T("unsigned char")) == static_cast('A')); // Verify that numbers are saved for signed and unsigned char - BOOST_CHECK(pt.get(T("signed char")) == int('A')); - BOOST_CHECK(pt.get(T("unsigned char")) == int('A')); + BOOST_TEST(pt.get(T("signed char")) == int('A')); + BOOST_TEST(pt.get(T("unsigned char")) == int('A')); // Verify ranges - BOOST_CHECK(pt.get(T("signed char min")) == + BOOST_TEST(pt.get(T("signed char min")) == (std::numeric_limits::min)()); - BOOST_CHECK(pt.get(T("signed char max")) == + BOOST_TEST(pt.get(T("signed char max")) == (std::numeric_limits::max)()); - BOOST_CHECK(pt.get(T("unsigned char min")) == + BOOST_TEST(pt.get(T("unsigned char min")) == (std::numeric_limits::min)()); - BOOST_CHECK(pt.get(T("unsigned char max")) == + BOOST_TEST(pt.get(T("unsigned char max")) == (std::numeric_limits::max)()); // Check that out-of-range throws. @@ -1321,7 +1329,7 @@ void test_float(PTREE*) pt.put(T("num"), difficult); double result = pt.get(T("num")); - BOOST_CHECK(!(result < difficult || result > difficult)); + BOOST_TEST(!(result < difficult || result > difficult)); } void test_sort(PTREE *) @@ -1335,21 +1343,21 @@ void test_sort(PTREE *) pt.sort(); PTREE::iterator it = pt.begin(); - BOOST_CHECK(std::distance(it, pt.end()) == 4); - BOOST_CHECK(it->first == T("four")); - BOOST_CHECK(it->second.data() == T("v4")); + BOOST_TEST(std::distance(it, pt.end()) == 4); + BOOST_TEST(it->first == T("four")); + BOOST_TEST(it->second.data() == T("v4")); ++it; - BOOST_CHECK(it->first == T("one")); - BOOST_CHECK(it->second.data() == T("v1")); + BOOST_TEST(it->first == T("one")); + BOOST_TEST(it->second.data() == T("v1")); ++it; - BOOST_CHECK(it->first == T("three")); - BOOST_CHECK(it->second.data() == T("v3")); + BOOST_TEST(it->first == T("three")); + BOOST_TEST(it->second.data() == T("v3")); ++it; - BOOST_CHECK(it->first == T("two")); - BOOST_CHECK(it->second.data() == T("v2")); + BOOST_TEST(it->first == T("two")); + BOOST_TEST(it->second.data() == T("v2")); } void test_leaks(PTREE *) { - //BOOST_CHECK(PTREE::debug_get_instances_count() == 0); + //BOOST_TEST(PTREE::debug_get_instances_count() == 0); } diff --git a/test/test_utils.hpp b/test/test_utils.hpp index 809f91f..4122e83 100644 --- a/test/test_utils.hpp +++ b/test/test_utils.hpp @@ -18,7 +18,7 @@ # define _CRT_SECURE_NO_DEPRECATE #endif -#include +#include #include #include #include @@ -65,7 +65,7 @@ public: std::ofstream stream(name.c_str()); using namespace std; stream.write(test_data, strlen(test_data)); - BOOST_CHECK(stream.good()); + BOOST_TEST(stream.good()); } } ~test_file() @@ -116,7 +116,7 @@ void generic_parser_test(Ptree &pt, rf(filename_out, pt2); // Read file again // Compare original with read - BOOST_CHECK(pt == pt2); + BOOST_TEST(pt == pt2); } @@ -160,9 +160,9 @@ void generic_parser_test_ok(ReadFunc rf, std::cerr << "Sizes: " << (unsigned)::total_size(pt) << ", " << (unsigned)::total_data_size(pt) << ", " << (unsigned)::total_keys_size(pt) << "\n"; // Check total sizes - BOOST_CHECK(actual_total_size == total_size); - BOOST_CHECK(actual_data_size == total_data_size); - BOOST_CHECK(actual_keys_size == total_keys_size); + BOOST_TEST(actual_total_size == total_size); + BOOST_TEST(actual_data_size == total_data_size); + BOOST_TEST(actual_keys_size == total_keys_size); } catch (std::runtime_error &e) @@ -205,8 +205,8 @@ void generic_parser_test_error(ReadFunc rf, } catch (Error &e) { - BOOST_CHECK(e.line() == expected_error_line); // Test line number - BOOST_CHECK(pt == get_test_ptree()); // Test if error damaged contents + BOOST_TEST(e.line() == expected_error_line); // Test line number + BOOST_TEST(pt == get_test_ptree()); // Test if error damaged contents } catch (...) { @@ -246,7 +246,7 @@ void check_exact_roundtrip(ReadFunc rf, WriteFunc wf, const char *test_data) { std::cerr << "(progress) Roundtripped data:\n"; errstream() << out_stream.str(); std::cerr << "\n-----\n"; - BOOST_CHECK(native_test_data == out_stream.str()); + BOOST_TEST(native_test_data == out_stream.str()); } #endif diff --git a/test/test_xml_parser_rapidxml.cpp b/test/test_xml_parser_rapidxml.cpp index ed24e5f..2362f6d 100644 --- a/test/test_xml_parser_rapidxml.cpp +++ b/test/test_xml_parser_rapidxml.cpp @@ -17,7 +17,7 @@ #include #include -int test_main(int argc, char *argv[]) +int main(int , char *[]) { using namespace boost::property_tree; test_xml_parser(); @@ -30,5 +30,5 @@ int test_main(int argc, char *argv[]) test_xml_parser(); test_xml_parser(); #endif - return 0; + return boost::report_errors(); }