Modernize codebase

- Enhance CMakeLists.txt files.
- Move to Boost Test from Google Test to support pre-C++11 compilers.
- Add more configurations on CI matrix builds.
- Other minor fixes

.github/depends/boost.sh

@@ -1,23 +1,37 @@
-#!/bin/sh
+#!/bin/bash
 
 usage()
 {
   cat <<EOL
   -b   - 32-bit or 64-bit library, maybe 32, 64 or both
   -t   - the toolset, maybe gcc, clang or both
+  -p   - installation prefix
 EOL
 }
 
 build_boost()
 {
-  BASE=`pwd`/..
+  mkdir $3 || exit 1
-  ./b2 -j4 --toolset=$1 --prefix=${BASE}/usr --libdir="${BASE}/usr/$1/lib$2" --with-chrono --with-context --with-filesystem --with-system --with-timer address-model=$2 install
+  ./b2 \
+      -j4 \
+      --toolset=$1 \
+      --prefix=$3 \
+      --with-test \
+      --with-headers \
+      --with-chrono \
+      --with-context \
+      --with-filesystem \
+      --with-system \
+      --with-timer \
+      address-model=$2 \
+      install || exit 1
 }
 
 bit="64"
 toolset="gcc"
+prefix="$HOME/boost-prefix"
 
-while getopts "b:t:" c; do
+while getopts "b:t:p:" c; do
   case "$c" in
     b)
       bit="$OPTARG"
@@ -27,24 +41,27 @@ while getopts "b:t:" c; do
       toolset="$OPTARG"
       [ "$toolset" != "gcc" ] && [ "$toolset" != "clang" ] && [ "$toolset" != "both" ] && usage && exit 1
       ;;
+    p)
+      prefix="$OPTARG"
+      ;;
     ?*)
       echo "invalid arguments." && exit 1
       ;;
   esac
 done
 
-wget https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.bz2
+wget https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.bz2 || exit 1
-tar xf boost_1_72_0.tar.bz2
+tar xf boost_1_76_0.tar.bz2 || exit 1
-cd boost_1_72_0
+cd boost_1_76_0
-./bootstrap.sh
+./bootstrap.sh || exit 1
 
 build()
 {
   if [ "$bit" = "both" ]; then
-    build_boost $1 32
+    build_boost $1 32 $prefix
-    build_boost $1 64
+    build_boost $1 64 $prefix
   else
-    build_boost $1 $bit
+    build_boost $1 $bit $prefix
   fi
 }
 

.github/depends/zlib.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+usage()
+{
+  cat <<EOL
+  -b   - 32-bit or 64-bit library, maybe 32 or 64
+  -p   - installation prefix
+EOL
+}
+
+bit="64"
+prefix="$HOME/zlib-prefix"
+
+while getopts "b:t:p:" c; do
+  case "$c" in
+    b)
+      bit="$OPTARG"
+      [ "$bit" != "32" ] && [ "$bit" != "64" ] && usage && exit 1
+      ;;
+    p)
+      prefix="$OPTARG"
+      ;;
+    ?*)
+      echo "invalid arguments." && exit 1
+      ;;
+  esac
+done
+
+wget https://zlib.net/zlib-1.2.11.tar.gz || exit 1
+tar -xf zlib-1.2.11.tar.gz || exit 1
+cd zlib-1.2.11
+
+mkdir $prefix
+cmake \
+    -D CMAKE_BUILD_TYPE=Release \
+    -D CMAKE_INSTALL_PREFIX=$prefix \
+    -D CMAKE_C_FLAGS="-m${bit}" \
+    -D CMAKE_SHARED_LINKER_FLAGS="-m${bit}" \
+    -S .
+cmake --build . --target install

.github/workflows/coverage.yml

@@ -10,7 +10,6 @@ on:
     - '*'
 
 jobs:
-
   codecov:
     timeout-minutes: 30
     runs-on: ubuntu-latest
@@ -20,37 +19,49 @@ jobs:
     - name: install depends
       run: |
         sudo apt-get update
-        sudo apt-get install g++-multilib lcov
+        sudo apt-get install g++-10-multilib lcov -y
+        ./ci/set_gcc_10.sh
+
     - name: Cache boost
       id: cache-boost
       uses: actions/cache@v1
       with:
-        path: usr
+        path: ~/boost-prefix/
-        key: ${{ runner.os }}-boost-20210508-1-72-0
+        key: ${{ runner.os }}-boost-64-1-76-0-20210613
+
     - name: Build boost
       if: steps.cache-boost.outputs.cache-hit != 'true'
-      run: ./.github/depends/boost.sh -b both -t gcc
+      run: ./.github/depends/boost.sh -b 64 -t gcc -p $HOME/boost-prefix/
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v1
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-64-1-2-11-20210613
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix/
+
     - name: Compile tests
       run: |
-        # install gtest
+        mkdir build
-        BASE=`pwd`
+        cmake \
-        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+            -D MSGPACK_CXX20=ON \
-        unzip -q googletest-release-1.7.0.zip
+            -D MSGPACK_32BIT=OFF \
-        cd googletest-release-1.7.0
+            -D MSGPACK_CHAR_SIGN=signed \
-        g++ -m64 src/gtest-all.cc -I. -Iinclude -c -fPIC
+            -D MSGPACK_USE_X3_PARSE=ON \
-        g++ -m64 src/gtest_main.cc -I. -Iinclude -c -fPIC
+            -D MSGPACK_BUILD_EXAMPLES=ON \
-        ar -rv libgtest.a gtest-all.o
+            -D MSGPACK_BUILD_TESTS=ON \
-        ar -rv libgtest_main.a gtest_main.o
+            -D CMAKE_BUILD_TYPE=Debug \
-        mkdir -p ${BASE}/usr/include
+            -D MSGPACK_GEN_COVERAGE=ON \
-        cp -r include/gtest ${BASE}/usr/include
+            -D CMAKE_PREFIX_PATH="$HOME/zlib-prefix;$HOME/boost-prefix" \
-        mkdir -p ${BASE}/usr/lib
+            -B build \
-        mv *.a ${BASE}/usr/lib
+            -S . || exit 1
-        cd ..
+        cmake --build build --target all || exit 1
+        ctest --test-dir build || exit 1
 
-        mkdir build && cd build
-        CMAKE_LIBRARY_PATH="${BASE}/build" GTEST_ROOT="${BASE}/usr" CMAKE_PREFIX_PATH="${BASE}/usr/gcc/lib64/cmake" cmake -DMSGPACK_CXX17=ON -DMSGPACK_32BIT=OFF -DMSGPACK_CHAR_SIGN=signed -DMSGPACK_USE_X3_PARSE=ON -DMSGPACK_BUILD_EXAMPLES=ON -DMSGPACK_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DMSGPACK_GEN_COVERAGE=ON ..
-        make -j4
-        make test
     - name: Upload coverage to Codecov
       working-directory: build
       run: |

.github/workflows/gha.yml

@@ -11,268 +11,200 @@ on:
 
 jobs:
   macos:
+    name: ${{ format('macOS arch={0} cxx{1} san={2} api={3} char={4} x3={5}', matrix.arch, matrix.cxx, matrix.sanitize, matrix.api, matrix.char_sign, matrix.x3_parse) }}
     runs-on: macos-latest
     strategy:
       fail-fast: false
       matrix:
-        pattern: [0, 1, 2, 3]
+        arch: [64]
+        cxx: [98, 11, 14, 17, 20]
+        sanitize: ["no", "undefined"]
+        api: [1, 2, 3]
+        char_sign: ["unsigned", "signed"]
+        x3_parse: ["OFF", "ON"]
     steps:
     - uses: actions/checkout@v1
+
     - name: Cache boost
       id: cache-boost
       uses: actions/cache@v1
       with:
-        path: usr
+        path: ~/boost-prefix/
-        key: ${{ runner.os }}-boost-20210508-1-72-0
+        key: ${{ runner.os }}-boost-1-76-0-20210612
+
     - name: Build boost
       if: steps.cache-boost.outputs.cache-hit != 'true'
-      run: ./.github/depends/boost.sh -b 64 -t clang
+      run: ./.github/depends/boost.sh -b ${{ matrix.arch }} -t clang -p $HOME/boost-prefix/
-    - name: build and test
+
-      env:
+    - name: Cache zlib
-        CXX: clang++
+      id: cache-zlib
+      uses: actions/cache@v1
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-${{ matrix.arch }}-1-2-11-20210623
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b ${{ matrix.arch }} -p $HOME/zlib-prefix/
+
+    - name: Build and test
       shell: bash
       run: |
-        BASE=`pwd`;
+        if [[ (${{ matrix.cxx }} -eq 98 || ${{ matrix.cxx }} -lt 14) && "${{ matrix.x3_parse }}" == "ON" ]]; then
-
+          echo "X3 parse is only supported with C++14 or newer - skip this configuration"
-        # matrix config
+          exit 0
-        if [ ${{ matrix.pattern }} == 0 ]; then
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="64"
-          export CHAR_SIGN="unsigned"
-          export API_VERSION="1"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 1 ]; then
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="64"
-          export CHAR_SIGN="signed"
-          export API_VERSION="3"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 2 ]; then
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="64"
-          export CHAR_SIGN="signed"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 3 ]; then
-          ACTION="ci/build_cmake.sh"
-          export ARCH="64"
-          export CHAR_SIGN="unsigned"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
         fi
 
-        # install gtest
+        export ARCH="${{ matrix.arch }}"
-        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        export API_VERSION="${{ matrix.api }}"
-        unzip -q googletest-release-1.7.0.zip
+        export CHAR_SIGN="${{ matrix.char_sign }}"
-        cd googletest-release-1.7.0
+        export X3_PARSE="${{ matrix.x3_parse }}"
-        $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c
+
-        $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c
+        if [ "${{ matrix.cxx }}" == "98" ]; then
-        ar -rv libgtest.a gtest-all.o
+          export MSGPACK_CXX_VERSION="MSGPACK_CXX11=OFF"
-        ar -rv libgtest_main.a gtest_main.o
+        else
-        mkdir -p ${BASE}/usr/include
+          export MSGPACK_CXX_VERSION="MSGPACK_CXX${{ matrix.cxx }}=ON"
-        cp -r include/gtest ${BASE}/usr/include
+        fi
-        mkdir -p ${BASE}/usr/lib
+
-        mv *.a ${BASE}/usr/lib
+        if [ "${{ matrix.sanitize }}" != "no" ]; then
-        cd ..
+          export SANITIZE="-fsanitize=${{ matrix.sanitize }} -fno-sanitize-recover=all"
+        fi
 
         # build and test
-        CMAKE_CXX_COMPILER="${CXX}" CMAKE_LIBRARY_PATH="${BASE}/usr/lib:${BASE}/build" GTEST_ROOT="${BASE}/usr" CMAKE_PREFIX_PATH="${BASE}/usr/clang/lib${ARCH}/cmake" CXXFLAGS="-Werror -g ${SANITIZE}" ${ACTION}
+        export CXX="clang++"
+        CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh
+
         cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
 
   linux:
-    runs-on: ubuntu-18.04
+    name: ${{ format('Linux {0} arch={1} cxx{2} san={3} api={4} char={5} x3={6}', matrix.compiler, matrix.arch, matrix.cxx, matrix.sanitize, matrix.api, matrix.char_sign, matrix.x3_parse) }}
+    runs-on: ubuntu-20.04
     strategy:
       fail-fast: false
       matrix:
-        pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        arch: [32, 64]
+        cxx: [98, 11, 14, 17, 20]
+        sanitize: ["no", "undefined"]
+        api: [1, 2, 3]
+        char_sign: ["unsigned", "signed"]
+        x3_parse: ["OFF", "ON"]
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
-    - name: install build depends
+
+    - name: Install build dependencies
+      shell: bash
       run: |
         sudo apt-get update
-        sudo apt-get install g++-multilib clang-8 valgrind
+        sudo apt-get install g++-10 cmake valgrind -y
+        if [ ${{ matrix.arch }} == 32 ]; then
+          sudo apt-get install g++-10-multilib -y
+        fi
+        ./ci/set_gcc_10.sh
+
     - name: Cache boost
       id: cache-boost
       uses: actions/cache@v1
       with:
-        path: usr
+        path: ~/boost-prefix/
-        key: ${{ runner.os }}-boost-20210508-1-72-0
+        key: ${{ runner.os }}-boost-${{ matrix.arch }}-1-76-0-20210613
+
     - name: Build boost
       if: steps.cache-boost.outputs.cache-hit != 'true'
-      run: ./.github/depends/boost.sh -b both -t gcc
+      run: ./.github/depends/boost.sh -b ${{ matrix.arch }} -t gcc -p $HOME/boost-prefix/
-    - name: build and test
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v1
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-${{ matrix.arch }}-1-2-11-20210613
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b ${{ matrix.arch }} -p $HOME/zlib-prefix/
+
+    - name: Build and test
       shell: bash
       run: |
-        BASE=`pwd`;
+        if [[ (${{ matrix.cxx }} -eq 98 || ${{ matrix.cxx }} -lt 14) && "${{ matrix.x3_parse }}" == "ON" ]]; then
-
+          echo "X3 parse is only supported with C++14 or newer - skip this configuration"
-        # matrix config
+          exit 0
-        if [ ${{ matrix.pattern }} == 0 ]; then
-          export CXX=clang++
-          ACTION="ci/build_cmake.sh"
-          export ARCH="64"
-          export CHAR_SIGN="unsigned"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 1 ]; then
-          export CXX=clang++
-          ACTION="ci/build_cmake.sh"
-          export ARCH="32"
-          export CHAR_SIGN="signed"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 2 ]; then
-          export CXX=clang++
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="64"
-          export CHAR_SIGN="signed"
-          export API_VERSION="3"
-          export X3_PARSE="ON"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 3 ]; then
-          export CXX=clang++
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="32"
-          export CHAR_SIGN="unsigned"
-          export API_VERSION="2"
-        fi
-        if [ ${{ matrix.pattern }} == 4 ]; then
-          export CXX=g++
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="64"
-          export CHAR_SIGN="signed"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 5 ]; then
-          export CXX=g++
-          ACTION="ci/build_cmake.sh"
-          export CXX17="ON"
-          export ARCH="32"
-          export CHAR_SIGN="unsigned"
-          export API_VERSION="3"
-          export X3_PARSE="ON"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 6 ]; then
-          export CXX=g++
-          ACTION="ci/build_cmake.sh"
-          export ARCH="64"
-          export CHAR_SIGN="unsigned"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 7 ]; then
-          export CXX=g++
-          ACTION="ci/build_cmake.sh"
-          export ARCH="32"
-          export CHAR_SIGN="signed"
-          export API_VERSION="1"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 8 ]; then
-          export CXX=g++
-          ACTION="ci/build_cmake.sh"
-          export ARCH="32"
-          export CHAR_SIGN="signed"
-          export API_VERSION="2"
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 9 ]; then
-          export CXX=clang++
-          ACTION="ci/build_regression.sh"
-          export ARCH="64"
-          export SAN="UBSAN"
-          export MSGPACK_FUZZ_REGRESSION="ON"
-          export CTEST_OUTPUT_ON_FAILURE=1
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
-        fi
-        if [ ${{ matrix.pattern }} == 10 ]; then
-          export CXX=clang++
-          ACTION="ci/build_regression.sh"
-          export ARCH="64"
-          export SAN="ASAN"
-          export MSGPACK_FUZZ_REGRESSION="ON"
-          export CTEST_OUTPUT_ON_FAILURE=1
-          export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
         fi
 
-        # install gtest
+        export ARCH="${{ matrix.arch }}"
-        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        export API_VERSION="${{ matrix.api }}"
-        unzip -q googletest-release-1.7.0.zip
+        export CHAR_SIGN="${{ matrix.char_sign }}"
-        cd googletest-release-1.7.0
+        export X3_PARSE="${{ matrix.x3_parse }}"
-        $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c -fPIC
-        $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c -fPIC
-        ar -rv libgtest.a gtest-all.o
-        ar -rv libgtest_main.a gtest_main.o
-        mkdir -p ${BASE}/usr/include
-        cp -r include/gtest ${BASE}/usr/include
-        mkdir -p ${BASE}/usr/lib
-        mv *.a ${BASE}/usr/lib
-        cd ..
 
-        # install zlib
+        if [ "${{ matrix.cxx }}" == "98" ]; then
-        if [ ${ARCH} == 32 ]; then
+          export MSGPACK_CXX_VERSION="MSGPACK_CXX11=OFF"
-          sudo apt-get install lib32z1-dev
+        else
+          export MSGPACK_CXX_VERSION="MSGPACK_CXX${{ matrix.cxx }}=ON"
+        fi
+
+        if [ "${{ matrix.sanitize }}" != "no" ]; then
+          export SANITIZE="-fsanitize=${{ matrix.sanitize }} -fno-sanitize-recover=all"
         fi
 
         # build and test
-        CMAKE_CXX_COMPILER="${CXX}" CMAKE_LIBRARY_PATH="${BASE}/usr/lib:${BASE}/build" GTEST_ROOT="${BASE}/usr" CMAKE_PREFIX_PATH="${BASE}/usr/gcc/lib${ARCH}/cmake" CXXFLAGS="-Werror -g ${SANITIZE}" MSGPACK_SAN="${SAN}" ${ACTION}
+
+        # g++
+        export CXX="g++-10"
+        CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh
+
+        # clang++
+        # with ubsan clang inserts undefined reference to `__mulodi4' on 32-bit build - skip this configuration
+        if ! [[ "${{ matrix.sanitize }}" == "undefined" && $ARCH -eq 32 ]]; then
+          export CXX="clang++-10"
+          CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh
+        fi
         cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
+
   windows:
-    runs-on: windows-2016
+    name: ${{ format('Windows cxx{0}', matrix.cxx) }}
+    runs-on: windows-2019
     strategy:
       fail-fast: false
       matrix:
-        pattern: [0, 1, 2]
+        # MSVC2019 only supports /std:c++14, /std:c++17 and /std:c++latest
+        cxx: [14, 17, 20]
     steps:
     - uses: actions/checkout@v1
+
     - name: Cache vcpkg
       id: cache-vcpkg
       uses: actions/cache@v1.0.3
       with:
         path: C:/vcpkg/installed/x64-windows
-        key: ${{ runner.os }}-vcpkg
+        key: ${{ runner.os }}-vcpkg-01072021
+
     - name: Build dependencies
       if: steps.cache-vcpkg.outputs.cache-hit != 'true'
       shell: powershell
       run: |
         vcpkg update
-        vcpkg install gtest:x64-windows
         vcpkg install zlib:x64-windows
         vcpkg install boost:x64-windows
+
     - name: Build and test
       shell: powershell
       run: |
-        if (${{ matrix.pattern }} -eq 0) {
+        $CPPVER="MSGPACK_CXX${{ matrix.cxx }}=ON"
-          $CPPVER="-DMSGPACK_CXX17=ON"
-        }
-        if (${{ matrix.pattern }} -eq 1) {
-          $CPPVER="-DMSGPACK_CXX11=ON"
-        }
-        if (${{ matrix.pattern }} -eq 2) {
-          $CPPVER="-DMSGPACK_CXX11=OFF"
-        }
 
-        $CUR=(Get-Location).Path
         md build
-        cd build
+        cmake `
-        cmake -A x64 -DBOOST_ROOT="$env:BOOST_ROOT_1_72_0" -DCMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" $CPPVER "-DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING" ..
+            -A x64 `
-        if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+            -G "Visual Studio 16 2019" `
-        cmake --build . --config Release
+            -D CMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" `
-        $pathbak="$env:PATH"
+            -D MSGPACK_BUILD_TESTS=ON `
-        $env:PATH="C:\vcpkg\installed\x64-windows\bin;$CUR\build\Release;$pathbak"
+            -D $CPPVER `
-        ctest -V
+            -D CMAKE_CXX_FLAGS="/D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING /D_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING /D_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING /W3 /WX" `
-        if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+            -B build `
-        $env:PATH=$pathbak
+            -S .
+        if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+        cmake --build build --config Release
+        if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+        ctest -VV --test-dir build -C Release
+        if ($LastExitCode -ne 0) { exit $LastExitCode }

CMakeLists.txt

@@ -1,11 +1,8 @@
-CMAKE_MINIMUM_REQUIRED (VERSION 3.0.0)
+CMAKE_MINIMUM_REQUIRED (VERSION 3.1 FATAL_ERROR)
 
-IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
+CMAKE_POLICY (SET CMP0054 NEW)
-    (CMAKE_VERSION VERSION_EQUAL 3.1))
-    CMAKE_POLICY(SET CMP0054 NEW)
-ENDIF ()
 
-PROJECT (msgpack CXX)
+PROJECT (msgpack LANGUAGES CXX)
 
 FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.hpp contents)
 STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
@@ -20,112 +17,61 @@ LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
 SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
 
 OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
+OPTION (MSGPACK_CXX14 "Using c++14 compiler" OFF)
 OPTION (MSGPACK_CXX17 "Using c++17 compiler" OFF)
-OPTION (MSGPACK_CXX20 "Using c++20 compiler (experimental)" OFF)
+OPTION (MSGPACK_CXX20 "Using c++20 compiler" OFF)
-OPTION (MSGPACK_32BIT "32bit compile" OFF)
+
+OPTION (MSGPACK_32BIT           "32bit compile"             OFF)
+OPTION (MSGPACK_USE_X3_PARSE    "Use Boost X3 parse"        OFF)
+OPTION (MSGPACK_BUILD_TESTS     "Build tests"               OFF)
+OPTION (MSGPACK_FUZZ_REGRESSION "Enable regression testing" OFF)
+OPTION (MSGPACK_BUILD_EXAMPLES  "Build msgpack examples"    OFF)
+OPTION (MSGPACK_GEN_COVERAGE    "Generate coverage report"  OFF)
+
+SET (CMAKE_CXX_STANDARD_REQUIRED ON)
 
 IF (MSGPACK_USE_X3_PARSE)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF (NOT (MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20))
-      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+        MESSAGE (FATAL_ERROR "MSGPACK_USE_X3_PARSE requires MSGPACK_CXX14 or newer")
-   # matches Clang and AppleClang
+    ENDIF ()
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+ENDIF ()
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+
-      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
+IF (MSGPACK_CXX20)
-      IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
+    SET (CMAKE_CXX_STANDARD 20)
-          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++14.")
+ELSEIF (MSGPACK_CXX17)
-      ENDIF ()
+    SET (CMAKE_CXX_STANDARD 17)
-   ENDIF ()
+ELSEIF (MSGPACK_CXX14)
+    SET (CMAKE_CXX_STANDARD 14)
+ELSEIF (MSGPACK_CXX11)
+    SET (CMAKE_CXX_STANDARD 11)
 ELSE ()
-   IF (MSGPACK_CXX20)
+    SET (CMAKE_CXX_STANDARD 98)
-      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-         SET (CMAKE_CXX_FLAGS "-std=c++20 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-         SET (CMAKE_CXX_FLAGS "-std=c++20 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-         # MESSAGE ( FATAL_ERROR "MSVC doesn't support C++20.")
-      ENDIF ()
-   ELSEIF (MSGPACK_CXX17)
-      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-         SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-         SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-         # MESSAGE ( FATAL_ERROR "MSVC doesn't support C++17.")
-      ENDIF ()
-   ELSEIF (MSGPACK_CXX11)
-      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-         SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-         SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-         IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
-             MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11.")
-         ENDIF ()
-      ENDIF ()
-   ELSE ()
-      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-         IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_STD_SUPPORT_VERSION}) OR
-             (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_STD_SUPPORT_VERSION}))
-             SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
-         ENDIF ()
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-         SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-         IF (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18)
-             SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_CPP03 ${CMAKE_CXX_FLAGS}")
-         ENDIF ()
-      ENDIF ()
-   ENDIF ()
 ENDIF ()
 
 IF (MSGPACK_32BIT)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
+        SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+        SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
+        SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+        SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-   ENDIF ()
+    ENDIF ()
 ENDIF ()
 
-OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
-
 SET (Boost_USE_MULTITHREADED      ON)
 SET (Boost_USE_STATIC_RUNTIME    OFF)
-FIND_PACKAGE (Boost REQUIRED COMPONENTS chrono system OPTIONAL_COMPONENTS timer)
-
-INCLUDE_DIRECTORIES (
-   ${Boost_INCLUDE_DIRS}
-)
-LINK_DIRECTORIES (
-   ${Boost_LIBRARY_DIRS}
-)
-IF (MSGPACK_BOOST_DIR)
-   INCLUDE_DIRECTORIES (
-      ${MSGPACK_BOOST_DIR}
-   )
-ENDIF ()
 
 IF (MSGPACK_CHAR_SIGN)
-   SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
 ENDIF ()
 
 IF (MSGPACK_DEFAULT_API_VERSION)
-   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}")
 ELSE ()
-   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=3 ${CMAKE_CXX_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=3 ${CMAKE_CXX_FLAGS}")
 ENDIF ()
 
-FIND_PACKAGE (GTest)
-FIND_PACKAGE (ZLIB)
-FIND_PACKAGE (Threads)
-IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND AND NOT "${MSGPACK_FUZZ_REGRESSION}" STREQUAL "ON")
-    OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON)
-    OPTION (MSGPACK_GEN_COVERAGE "Enable running gcov to get a test coverage report." OFF)
-ENDIF ()
-
-
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.1)
         INCLUDE (CheckCXXSourceCompiles)
@@ -143,35 +89,31 @@ int main(int argc, char * argv[])
     ENDIF ()
 ENDIF ()
 
+FIND_PACKAGE (Boost REQUIRED)
 
 INCLUDE (Files.cmake)
 
-ADD_LIBRARY (msgpackcxx INTERFACE)
+ADD_LIBRARY (msgpackc-cxx INTERFACE)
 
-TARGET_INCLUDE_DIRECTORIES (msgpackcxx
+TARGET_INCLUDE_DIRECTORIES (msgpackc-cxx
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
         $<INSTALL_INTERFACE:include>
 )
 
-# enable regression testing
+TARGET_LINK_LIBRARIES (msgpackc-cxx INTERFACE Boost::boost)
-IF ("${MSGPACK_FUZZ_REGRESSION}" STREQUAL "ON" AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-   enable_testing ()
-   ADD_SUBDIRECTORY (fuzz)
-   SET (MSGPACK_BUILD_EXAMPLES OFF)
-ENDIF ()
 
 IF (MSGPACK_GEN_COVERAGE)
     IF (NOT MSGPACK_BUILD_TESTS)
         MESSAGE(FATAL_ERROR "Coverage requires -DMSGPACK_BUILD_TESTS=ON")
     ENDIF ()
-    STRING(TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_CMAKE_BUILD_TYPE)
+    STRING (TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_CMAKE_BUILD_TYPE)
     IF (NOT "${UPPER_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
-        MESSAGE(FATAL_ERROR "Coverage requires -DCMAKE_BUILD_TYPE=Debug")
+        MESSAGE (FATAL_ERROR "Coverage requires -DCMAKE_BUILD_TYPE=Debug")
     ENDIF ()
 
-    INCLUDE(CodeCoverage)
+    INCLUDE (CodeCoverage)
     SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS}")
 
     SETUP_TARGET_FOR_COVERAGE(coverage make coverage test)
@@ -181,17 +123,15 @@ IF (MSGPACK_BUILD_TESTS)
     ENABLE_TESTING ()
     # MEMORYCHECK_COMMAND_OPTIONS needs to place prior to CTEST_MEMORYCHECK_COMMAND
     SET (MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --show-leak-kinds=definite,possible --error-exitcode=1")
-    FIND_PROGRAM(CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
+    FIND_PROGRAM (CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
-    INCLUDE(Dart)
+    INCLUDE (Dart)
     ADD_SUBDIRECTORY (test)
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+# enable regression testing
-    IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+IF (MSGPACK_FUZZ_REGRESSION)
-        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    ENABLE_TESTING ()
-    ELSE ()
+    ADD_SUBDIRECTORY (fuzz)
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-    ENDIF ()
 ENDIF ()
 
 IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
@@ -202,11 +142,6 @@ IF (MSGPACK_BUILD_EXAMPLES)
     ADD_SUBDIRECTORY (example)
 ENDIF ()
 
-FOREACH (file ${msgpackc_HEADERS})
-    GET_FILENAME_COMPONENT (dir ${file} PATH)
-    INSTALL (FILES ${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
-ENDFOREACH ()
-
 # Doxygen
 FIND_PACKAGE (Doxygen)
 IF (DOXYGEN_FOUND)
@@ -231,3 +166,54 @@ IF (DOXYGEN_FOUND)
         VERBATIM
     )
 ENDIF ()
+
+# Install library.
+INSTALL (TARGETS msgpackc-cxx
+         EXPORT msgpackc-cxx-targets
+         COMPONENT msgpackc-cxx
+         # This provides include directory in exported target
+         # relative to prefix in single directory we've put everything in.
+         INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+# Install headers from source tree.
+INSTALL (DIRECTORY include/
+         TYPE INCLUDE
+         COMPONENT msgpackc-cxx
+)
+
+INCLUDE (CMakePackageConfigHelpers)
+
+SET (extra_version_file_args ARCH_INDEPENDENT)
+SET (cmake_config_path "lib/cmake/msgpackc-cxx")
+
+# Configure the main package file from source tree.
+CONFIGURE_PACKAGE_CONFIG_FILE (
+    msgpack-config.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+    INSTALL_DESTINATION "${cmake_config_path}"
+)
+
+# Write package version file.
+WRITE_BASIC_PACKAGE_VERSION_FILE (
+    msgpack-config-version.cmake
+    VERSION ${VERSION}
+    COMPATIBILITY SameMajorVersion
+    ${extra_version_file_args}
+)
+
+# Install the generated package version file and the main package file.
+INSTALL (FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake"
+    DESTINATION "${cmake_config_path}"
+    COMPONENT msgpackc-cxx
+)
+
+# This installs package in install tree for using installed targets.
+INSTALL (
+    EXPORT msgpackc-cxx-targets
+    FILE msgpackc-cxx-targets.cmake
+    DESTINATION "${cmake_config_path}"
+    COMPONENT msgpackc-cxx
+)

Files.cmake

@@ -70,6 +70,7 @@ SET (msgpackc_HEADERS
     include/msgpack/adaptor/wstring.hpp
     include/msgpack/cpp_config.hpp
     include/msgpack/cpp_config_decl.hpp
+    include/msgpack/cpp_version.hpp
     include/msgpack/create_object_visitor.hpp
     include/msgpack/create_object_visitor_decl.hpp
     include/msgpack/fbuffer.hpp

ci/build_cmake.sh

@@ -1,66 +1,37 @@
 #!/bin/bash
 
-mkdir build
+mkdir $CXX-build  || exit 1
-
+mkdir $CXX-prefix || exit 1
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-cd build
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
 
 if [ "${ARCH}" == "32" ]
 then
     export BIT32="ON"
     export ARCH_FLAG="-m32"
-    ZLIB32="-DZLIB_LIBRARY=/usr/lib32/libz.a"
 else
     export BIT32="OFF"
     export ARCH_FLAG="-m64"
 fi
 
-cmake -DMSGPACK_CXX11=${CXX11} -DMSGPACK_CXX17=${CXX17} -DMSGPACK_32BIT=${BIT32} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DMSGPACK_DEFAULT_API_VERSION=${API_VERSION} -DMSGPACK_USE_X3_PARSE=${X3_PARSE} -DCMAKE_CXX_FLAGS="${ARCH_FLAG} ${CXXFLAGS}" ${ZLIB32} ..
+cmake \
+    -D CMAKE_PREFIX_PATH="$HOME/boost-prefix;$HOME/zlib-prefix" \
+    -D MSGPACK_BUILD_TESTS=ON \
+    -D ${MSGPACK_CXX_VERSION} \
+    -D MSGPACK_32BIT=${BIT32} \
+    -D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
+    -D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
+    -D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
+    -D CMAKE_CXX_FLAGS="${CXXFLAGS} ${ARCH_FLAG}" \
+    -D CMAKE_INSTALL_PREFIX=`pwd`/$CXX-prefix \
+    -B $CXX-build \
+    -S . || exit 1
 
-ret=$?
+cmake --build $CXX-build --target install || exit 1
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
 
-make
+ctest -VV --test-dir $CXX-build || exit 1
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-ctest -VV
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-make install DESTDIR=`pwd`/install
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
 
 if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]
 then
-    ctest -T memcheck | tee memcheck.log
+    ctest -T memcheck --test-dir $CXX-build | tee memcheck.log
 
     ret=${PIPESTATUS[0]}
     if [ $ret -ne 0 ]
@@ -77,37 +48,14 @@ fi
 
 if [ "${ARCH}" != "32" ]
 then
-    mkdir install-test
+    cd test-install || exit 1
 
-    ret=$?
+    mkdir $CXX-build
-    if [ $ret -ne 0 ]
+    cmake \
-    then
+        -D CMAKE_PREFIX_PATH="`pwd`/../$CXX-prefix;$HOME/boost-prefix" \
-        exit $ret
+        -B $CXX-build \
-    fi
+        -S . || exit 1
+    cmake --build $CXX-build --target all || exit 1
 
-    cd install-test
+    $CXX-build/test-install || exit 1
-
-    ret=$?
-    if [ $ret -ne 0 ]
-    then
-        exit $ret
-    fi
-
-    ${CXX} ../../example/cpp03/simple.cpp -o simple -I `pwd`/../install/usr/local/include -I ${GTEST_ROOT}/include -L ${GTEST_ROOT}/lib -lgtest_main -lgtest
-
-    ret=$?
-    if [ $ret -ne 0 ]
-    then
-        exit $ret
-    fi
-
-    ./simple
-
-    ret=$?
-    if [ $ret -ne 0 ]
-    then
-        exit $ret
-    fi
 fi
-
-exit 0

ci/build_regression.sh

@@ -1,20 +1,6 @@
 #!/bin/bash
 
-mkdir -p build
+mkdir build || exit 1
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-cd build
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
 
 if [ "${ARCH}" == "32" ]
 then
@@ -22,28 +8,17 @@ then
     exit 1
 fi
 
-cmake -DMSGPACK_FUZZ_REGRESSION="ON" -DMSGPACK_CXX11="ON" -DMSGPACK_SAN=${MSGPACK_SAN} ..
+cmake \
+    -D CMAKE_PREFIX_PATH="$HOME/boost-prefix;$HOME/zlib-prefix" \
+    -D MSGPACK_FUZZ_REGRESSION="ON" \
+    -D ${MSGPACK_CXX_VERSION} \
+    -D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
+    -D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
+    -D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
+    -D CMAKE_CXX_FLAGS="${CXXFLAGS}" \
+    -B build \
+    -S . || exit 1
 
-ret=$?
+cmake --build . --target all || exit 1
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
 
-make
+ctest -VV --test-dir build || exit 1
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-make test
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-exit 0

ci/set_gcc_10.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+version=10
+priority=100
+
+sudo update-alternatives --install /usr/bin/gcc         gcc         /usr/bin/gcc-${version}         ${priority}
+sudo update-alternatives --install /usr/bin/gcc-ar      gcc-ar      /usr/bin/gcc-ar-${version}      ${priority}
+sudo update-alternatives --install /usr/bin/gcc-nm      gcc-nm      /usr/bin/gcc-nm-${version}      ${priority}
+sudo update-alternatives --install /usr/bin/gcc-ranlib  gcc-ranlib  /usr/bin/gcc-ranlib-${version}  ${priority}
+sudo update-alternatives --install /usr/bin/gcov        gcov        /usr/bin/gcov-${version}        ${priority}
+sudo update-alternatives --install /usr/bin/gcov-dump   gcov-dump   /usr/bin/gcov-dump-${version}   ${priority}
+sudo update-alternatives --install /usr/bin/gcov-tool   gcov-tool   /usr/bin/gcov-tool-${version}   ${priority}
+sudo update-alternatives --install /usr/bin/lto-dump    lto-dump    /usr/bin/lto-dump-${version}    ${priority}
+sudo update-alternatives --install /usr/bin/g++         g++         /usr/bin/g++-${version}         ${priority}
+
+sudo update-alternatives --install /usr/bin/cc   cc   /usr/bin/gcc-${version} ${priority}
+sudo update-alternatives --install /usr/bin/c++  c++  /usr/bin/g++-${version} ${priority}

example/boost/CMakeLists.txt

@@ -1,19 +1,16 @@
+FIND_PACKAGE (Boost REQUIRED COMPONENTS system)
+FIND_PACKAGE (Threads REQUIRED)
+FIND_PACKAGE (ZLIB REQUIRED)
+
 LIST (APPEND exec_PROGRAMS
     msgpack_variant_capitalize.cpp
     msgpack_variant_mapbased.cpp
 )
-IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
+
-    FIND_PACKAGE (Threads REQUIRED)
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
-    LIST (APPEND exec_PROGRAMS
+    LIST (APPEND exec_PROGRAMS asio_send_recv.cpp)
-        asio_send_recv.cpp
-    )
     IF (ZLIB_FOUND)
-        INCLUDE_DIRECTORIES (
+        LIST (APPEND exec_PROGRAMS asio_send_recv_zlib.cpp)
-            ${ZLIB_INCLUDE_DIRS}
-        )
-        LIST (APPEND exec_PROGRAMS
-            asio_send_recv_zlib.cpp
-        )
     ENDIF ()
 ENDIF ()
 
@@ -23,19 +20,14 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
-    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        PRIVATE
+        msgpackc-cxx
-            $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
+        Boost::system
-    )
+        Threads::Threads
-    TARGET_LINK_LIBRARIES (${source_file_we}
-        ${Boost_SYSTEM_LIBRARY}
-        ${CMAKE_THREAD_LIBS_INIT}
     )
     IF (ZLIB_FOUND)
-        TARGET_LINK_LIBRARIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE ZLIB::ZLIB)
-            ${ZLIB_LIBRARIES}
+    ENDIF ()
-        )
-    ENDIF()
     IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
     ENDIF ()

example/boost/asio_send_recv_zlib.cpp

@@ -85,12 +85,12 @@ int main() {
                             }
                             std::cout << bytes_transferred << " bytes read." << std::endl;
                             print(std::string(std::string(&buf[0], buf.size())));
-                            strm.avail_in = bytes_transferred;
+                            strm.avail_in = static_cast<uInt>(bytes_transferred);
                             do {
                                 strm.next_in = reinterpret_cast<unsigned char*>(&buf[0]) + (bytes_transferred - strm.avail_in);
                                 int zret;
                                 unp.reserve_buffer(window_size);
-                                strm.avail_out = window_size;
+                                strm.avail_out = static_cast<uInt>(window_size);
                                 strm.next_out = reinterpret_cast<unsigned char*>(unp.buffer());
                                 do {
                                     zret = inflate(&strm, Z_NO_FLUSH);

example/cpp03/CMakeLists.txt

@@ -1,3 +1,7 @@
+FIND_PACKAGE (Threads REQUIRED)
+
+FIND_PACKAGE (Boost COMPONENTS timer)
+
 LIST (APPEND exec_PROGRAMS
     class_intrusive.cpp
     class_intrusive_map.cpp
@@ -35,9 +39,8 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
-    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        PRIVATE
+        msgpackc-cxx
-            $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
     )
     IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
@@ -57,12 +60,9 @@ FOREACH (source_file ${with_pthread_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
-    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        PRIVATE
+        msgpackc-cxx
-            $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
+        Threads::Threads
-    )
-    TARGET_LINK_LIBRARIES (${source_file_we}
-        ${CMAKE_THREAD_LIBS_INIT}
     )
     IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
@@ -77,27 +77,17 @@ FOREACH (source_file ${with_pthread_PROGRAMS})
 ENDFOREACH ()
 
 FOREACH (source_file ${with_boost_lib_PROGRAMS})
-    INCLUDE_DIRECTORIES (
-        ../include
-        ${Boost_INCLUDE_DIRS}
-    )
     GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
     ADD_EXECUTABLE (
         ${source_file_we}
         ${source_file}
     )
-    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        PRIVATE
+        msgpackc-cxx
-            $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
+        Boost::timer
-    )
-    LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
-    TARGET_LINK_LIBRARIES (${source_file_we}
-        ${Boost_TIMER_LIBRARY}
-        ${Boost_CHRONO_LIBRARY}
-        ${Boost_SYSTEM_LIBRARY}
     )
     IF (NOT MSVC AND NOT APPLE)
-        TARGET_LINK_LIBRARIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
             rt
         )
     ENDIF ()

example/cpp11/CMakeLists.txt

@@ -1,8 +1,4 @@
-IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17)
-    INCLUDE_DIRECTORIES (
-        ../include
-    )
-
     LIST (APPEND exec_PROGRAMS
         container.cpp
         non_def_con_class.cpp
@@ -20,9 +16,8 @@ IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
             ${source_file_we}
             ${source_file}
         )
-        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-            PRIVATE
+            msgpackc-cxx
-                $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
         )
         IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")

example/x3/CMakeLists.txt

@@ -1,9 +1,6 @@
 IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
-    FIND_PACKAGE (Boost REQUIRED COMPONENTS context)
+    FIND_PACKAGE (Boost REQUIRED COMPONENTS context system unit_test_framework)
-
+    FIND_PACKAGE (Threads REQUIRED)
-    INCLUDE_DIRECTORIES (
-        ../include
-    )
 
     LIST (APPEND exec_PROGRAMS
         unpack.cpp
@@ -18,10 +15,8 @@ IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
             ${source_file_we}
             ${source_file}
         )
-        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpackc-cxx)
-            PRIVATE
+
-                $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
-        )
         IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
         ENDIF ()
@@ -44,14 +39,12 @@ IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
             ${source_file_we}
             ${source_file}
         )
-        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-            PRIVATE
+            msgpackc-cxx
-                $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
+            Boost::context
-        )
+            Boost::system
-        TARGET_LINK_LIBRARIES (${source_file_we}
+            Boost::unit_test_framework
-            ${Boost_CONTEXT_LIBRARY}
+            Threads::Threads
-            ${Boost_SYSTEM_LIBRARY}
-            ${CMAKE_THREAD_LIBS_INIT}
         )
         IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")

fuzz/CMakeLists.txt

@@ -1,21 +1,10 @@
-FIND_PACKAGE (GTest REQUIRED)
+FIND_PACKAGE (Threads REQUIRED)
-FIND_PACKAGE (ZLIB REQUIRED)
+FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem unit_test_framework)
-FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem)
-
-INCLUDE_DIRECTORIES (
-  ${GTEST_INCLUDE_DIRS}
-  ${ZLIB_INCLUDE_DIRS}
-  ${Boost_INCLUDE_DIRS}
-)
 
 LIST (APPEND check_PROGRAMS
     regression_runner.cpp
 )
 
-LINK_DIRECTORIES (
-  ${Boost_LIBRARY_DIRS}
-)
-
 FOREACH (source_file ${check_PROGRAMS})
     GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
     ADD_EXECUTABLE (
@@ -23,11 +12,11 @@ FOREACH (source_file ${check_PROGRAMS})
         ${source_file}
     )
     TARGET_LINK_LIBRARIES (${source_file_we}
-        msgpackcxx
+        msgpackc-cxx
-        ${GTEST_BOTH_LIBRARIES}
+        Threads::Threads
-        ${ZLIB_LIBRARIES}
+        Boost::filesystem
-        ${CMAKE_THREAD_LIBS_INIT}
+        Boost::system
-        ${Boost_LIBRARIES}
+        Boost::unit_test_framework
     )
     ADD_TEST (${source_file_we} ${source_file_we})
     IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")

fuzz/regression_runner.cpp

@@ -1,50 +1,49 @@
 #include <boost/filesystem.hpp>
-#include <gtest/gtest.h>
+
+// Use parameterized tests instead of modern data-driven test cases
+// because BOOST_DATA_TEST_CASE requires C++11 or newer. See:
+// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/param_test.html
+// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/test_case_generation.html
+#include <boost/test/included/unit_test.hpp>
+#include <boost/test/parameterized_test.hpp>
 
 #include <fstream>
-#include <iostream>
+#include <string>
 #include <vector>
 
 #include "unpack_pack_fuzzer.cpp"
 
-using ::testing::TestWithParam;
-using ::testing::ValuesIn;
-
-
 std::vector<std::string> ListDirectory(const std::string& path) {
   std::vector<std::string> v;
 
   boost::filesystem::path p(path);
-  boost::filesystem::directory_iterator f{p};
+  boost::filesystem::directory_iterator f(p);
 
-  if(boost::filesystem::is_directory(p)) {
+  if (boost::filesystem::is_directory(p)) {
-    while (f != boost::filesystem::directory_iterator{}) {
+    while (f != boost::filesystem::directory_iterator()) {
       v.push_back((*f++).path().string());
     }
   }
   return v;
 }
 
-class UnpackPackFuzzerRegressionTest : public ::testing::TestWithParam<std::string> {
+void UnpackPackFuzzerRegressionTest(const std::string& fpath) {
-public:
+  std::ifstream in(fpath.c_str(), std::ios_base::binary);
-};
-
-TEST_P(UnpackPackFuzzerRegressionTest, Returns0) {
-  auto fpath = GetParam();
-  std::ifstream in(fpath, std::ifstream::binary);
   if (!in) {
-    FAIL() << fpath << " not found";
+    BOOST_FAIL(fpath + " not found");
   }
   in.seekg(0, in.end);
   size_t length = in.tellg();
   in.seekg(0, in.beg);
   std::vector<char> bytes(length);
   in.read(bytes.data(), bytes.size());
-  assert(in);
+  BOOST_REQUIRE(in);
-  EXPECT_EQ(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
+  BOOST_REQUIRE_EQUAL(0, FuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()), bytes.size()));
-                                      bytes.size()));
 }
 
-INSTANTIATE_TEST_CASE_P(UnpackPackFuzzerRegressions,
+boost::unit_test::test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[])
-                        UnpackPackFuzzerRegressionTest,
+{
-                        ::testing::ValuesIn(ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions")));
+  std::vector<std::string> files = ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions");
+  boost::unit_test::framework::master_test_suite().add(BOOST_PARAM_TEST_CASE(&UnpackPackFuzzerRegressionTest, files.begin(), files.end()));
+  return 0;
+}

fuzz/unpack_pack_fuzzer.cpp

@@ -1,14 +1,14 @@
 #include <msgpack.hpp>
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int FuzzerTestOneInput(const uint8_t *data, size_t size) {
   try {
     // NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm
     // setting these at far smaller values to avoid OOMs
     const int test_limit = 1000;
     msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
                                                       size,
-                                                      nullptr,
+                                                      MSGPACK_NULLPTR,
-                                                      nullptr,
+                                                      MSGPACK_NULLPTR,
                                                       msgpack::unpack_limit(test_limit,
                                                                             test_limit,
                                                                             test_limit,

include/msgpack/cpp_version.hpp

@@ -0,0 +1,18 @@
+#ifndef MSGPACK_CPP_VERSION_HPP
+#define MSGPACK_CPP_VERSION_HPP
+
+#if defined(_MSC_VER)
+#  if _MSC_VER < 1900
+#    define MSGPACK_USE_CPP03
+#  endif
+#elif (__cplusplus < 201103L)
+#  define MSGPACK_USE_CPP03
+#endif
+
+#if defined(_MSVC_LANG)
+#  define MSGPACK_CPP_VERSION _MSVC_LANG
+#else
+#  define MSGPACK_CPP_VERSION __cplusplus
+#endif
+
+#endif // MSGPACK_CPP_VERSION_HPP

include/msgpack/v1/adaptor/cpp17/array_byte.hpp

@@ -10,7 +10,9 @@
 #ifndef MSGPACK_V1_TYPE_ARRAY_BYTE_HPP
 #define MSGPACK_V1_TYPE_ARRAY_BYTE_HPP
 
-#if __cplusplus >= 201703
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -116,6 +118,6 @@ struct object_with_zone<std::array<std::byte, N> > {
 
 } // namespace msgpack
 
-#endif // __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703
 
 #endif // MSGPACK_V1_TYPE_ARRAY_BYTE_HPP

include/msgpack/v1/adaptor/cpp17/byte.hpp

@@ -10,7 +10,9 @@
 #ifndef MSGPACK_V1_TYPE_BYTE_HPP
 #define MSGPACK_V1_TYPE_BYTE_HPP
 
-#if __cplusplus >= 201703
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -69,6 +71,6 @@ struct object_with_zone<std::byte> {
 
 } // namespace msgpack
 
-#endif // __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703
 
 #endif // MSGPACK_V1_TYPE_BYTE_HPP

include/msgpack/v1/adaptor/cpp17/carray_byte.hpp

@@ -10,7 +10,9 @@
 #ifndef MSGPACK_V1_TYPE_CARRAY_BYTE_HPP
 #define MSGPACK_V1_TYPE_CARRAY_BYTE_HPP
 
-#if __cplusplus >= 201703
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -104,6 +106,6 @@ struct object_with_zone<const std::byte[N]> {
 
 } // namespace msgpack
 
-#endif // __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703
 
 #endif // MSGPACK_V1_TYPE_CARRAY_BYTE_HPP

include/msgpack/v1/adaptor/cpp17/optional.hpp

@@ -10,7 +10,9 @@
 #ifndef MSGPACK_V1_TYPE_OPTIONAL_HPP
 #define MSGPACK_V1_TYPE_OPTIONAL_HPP
 
-#if __cplusplus >= 201703
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -85,6 +87,6 @@ struct object_with_zone<std::optional<T> > {
 
 } // namespace msgpack
 
-#endif // __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703
 
 #endif // MSGPACK_V1_TYPE_OPTIONAL_HPP

include/msgpack/v1/adaptor/cpp17/string_view.hpp

@@ -10,7 +10,9 @@
 #ifndef MSGPACK_V1_TYPE_STRING_VIEW_HPP
 #define MSGPACK_V1_TYPE_STRING_VIEW_HPP
 
-#if __cplusplus >= 201703
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -81,6 +83,6 @@ struct object_with_zone<std::string_view> {
 
 } // namespace msgpack
 
-#endif // __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703
 
 #endif // MSGPACK_V1_TYPE_STRING_VIEW_HPP

include/msgpack/v1/adaptor/cpp17/vector_byte.hpp

@@ -10,7 +10,9 @@
 #ifndef MSGPACK_V1_TYPE_VECTOR_BYTE_HPP
 #define MSGPACK_V1_TYPE_VECTOR_BYTE_HPP
 
-#if __cplusplus >= 201703
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -114,6 +116,6 @@ struct object_with_zone<std::vector<std::byte, Alloc> > {
 
 } // namespace msgpack
 
-#endif // __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703
 
 #endif // MSGPACK_V1_TYPE_VECTOR_BYTE_HPP

include/msgpack/v1/adaptor/cpp20/span.hpp

@@ -11,8 +11,10 @@
 #ifndef MSGPACK_V1_TYPE_CPP20_SPAN_HPP
 #define MSGPACK_V1_TYPE_CPP20_SPAN_HPP
 
-// Some compilers still do not set __cplusplus to 202002
+#include "msgpack/cpp_version.hpp"
-#if __cplusplus > 201703
+
+// Some compilers still do not set the corresponding macro to 202002
+#if MSGPACK_CPP_VERSION > 201703
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -116,6 +118,6 @@ MSGPACK_ADAPTOR_SPAN_BINARY(std::byte)
 
 } // namespace msgpack
 
-#endif // __cplusplus > 201703
+#endif // MSGPACK_CPP_VERSION > 201703
 
 #endif // MSGPACK_V1_TYPE_CPP11_ARRAY_HPP

include/msgpack/v1/adaptor/map.hpp

@@ -10,6 +10,8 @@
 #ifndef MSGPACK_V1_TYPE_MAP_HPP
 #define MSGPACK_V1_TYPE_MAP_HPP
 
+#include "msgpack/versioning.hpp"
+#include "msgpack/cpp_version.hpp"
 #include "msgpack/v1/adaptor/map_decl.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 
@@ -154,13 +156,13 @@ struct convert<std::map<K, V, Compare, Alloc> > {
         for (; p != pend; ++p) {
             K key;
             p->key.convert(key);
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
             p->val.convert(tmp[std::move(key)]);
 #else
             p->val.convert(tmp[key]);
 #endif
         }
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
         v = std::move(tmp);
 #else
         tmp.swap(v);
@@ -248,13 +250,13 @@ struct convert<std::multimap<K, V, Compare, Alloc> > {
             std::pair<K, V> value;
             p->key.convert(value.first);
             p->val.convert(value.second);
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
             tmp.insert(std::move(value));
 #else
             tmp.insert(value);
 #endif
         }
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
         v = std::move(tmp);
 #else
         tmp.swap(v);

include/msgpack/v1/adaptor/raw.hpp

@@ -34,7 +34,7 @@ struct raw_ref {
 
     bool operator== (const raw_ref& x) const
     {
-        return size == x.size && std::memcmp(ptr, x.ptr, size) == 0;
+        return size == x.size && (size == 0 || std::memcmp(ptr, x.ptr, size) == 0);
     }
 
     bool operator!= (const raw_ref& x) const
@@ -44,13 +44,13 @@ struct raw_ref {
 
     bool operator< (const raw_ref& x) const
     {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; }
+        if(size == x.size) { return (size == 0 ? false : std::memcmp(ptr, x.ptr, size) < 0); }
         else { return size < x.size; }
     }
 
     bool operator> (const raw_ref& x) const
     {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; }
+        if(size == x.size) { return (size == 0 ? false : std::memcmp(ptr, x.ptr, size) > 0); }
         else { return size > x.size; }
     }
 };

include/msgpack/v1/adaptor/set.hpp

@@ -11,6 +11,7 @@
 #define MSGPACK_V1_TYPE_SET_HPP
 
 #include "msgpack/versioning.hpp"
+#include "msgpack/cpp_version.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/adaptor/check_container_size.hpp"
 
@@ -54,7 +55,7 @@ struct convert<std::set<T, Compare, Alloc> > {
             --p;
             tmp.insert(p->as<T>());
         }
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
         v = std::move(tmp);
 #else
         tmp.swap(v);
@@ -131,7 +132,7 @@ struct convert<std::multiset<T, Compare, Alloc> > {
             --p;
             tmp.insert(p->as<T>());
         }
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
         v = std::move(tmp);
 #else
         tmp.swap(v);

include/msgpack/v1/adaptor/string.hpp

@@ -30,10 +30,16 @@ struct convert<std::string> {
     msgpack::object const& operator()(msgpack::object const& o, std::string& v) const {
         switch (o.type) {
         case msgpack::type::BIN:
-            v.assign(o.via.bin.ptr, o.via.bin.size);
+            if (o.via.bin.size == 0)
+                v.clear();
+            else
+                v.assign(o.via.bin.ptr, o.via.bin.size);
             break;
         case msgpack::type::STR:
-            v.assign(o.via.str.ptr, o.via.str.size);
+            if (o.via.str.size == 0)
+                v.clear();
+            else
+                v.assign(o.via.str.ptr, o.via.str.size);
             break;
         default:
             throw msgpack::type_error();

include/msgpack/v1/cpp_config.hpp

@@ -11,6 +11,8 @@
 #define MSGPACK_V1_CPP_CONFIG_HPP
 
 #include "msgpack/cpp_config_decl.hpp"
+#include "msgpack/cpp_version.hpp"
+#include "msgpack/versioning.hpp"
 
 #if defined(MSGPACK_USE_CPP03)
 
@@ -126,14 +128,14 @@ template<class T> struct is_pointer : detail::is_pointer_helper<typename remove_
 
 #endif // MSGPACK_USE_CPP03
 
-#if __cplusplus >= 201402L
+#if MSGPACK_CPP_VERSION >= 201402L
 #if defined(_MSC_VER)
 #define MSGPACK_DEPRECATED(msg) __declspec(deprecated(msg))
-#else  // _MSC_VER 1914+ with /Zc:__cplusplus, @see https://docs.microsoft.com/cpp/build/reference/zc-cplusplus
+#else
 #define MSGPACK_DEPRECATED(msg) [[deprecated(msg)]]
 #endif
-#else  // __cplusplus >= 201402L
+#else  // MSGPACK_CPP_VERSION >= 201402L
 #define MSGPACK_DEPRECATED(msg)
-#endif // __cplusplus >= 201402L
+#endif // MSGPACK_CPP_VERSION >= 201402L
 
 #endif // MSGPACK_V1_CPP_CONFIG_HPP

include/msgpack/v1/cpp_config_decl.hpp

@@ -10,19 +10,9 @@
 #ifndef MSGPACK_V1_CPP_CONFIG_DECL_HPP
 #define MSGPACK_V1_CPP_CONFIG_DECL_HPP
 
+#include "msgpack/cpp_version.hpp"
 #include "msgpack/versioning.hpp"
 
-#if !defined(MSGPACK_USE_CPP03)
-# if defined(_MSC_VER)
-#  if _MSC_VER < 1900
-#    define MSGPACK_USE_CPP03
-#  endif
-# elif (__cplusplus < 201103L)
-#  define MSGPACK_USE_CPP03
-# endif
-#endif // MSGPACK_USE_CPP03
-
-
 #if defined(MSGPACK_USE_CPP03)
 
 #if defined(nullptr)

include/msgpack/v1/versioning.hpp

@@ -10,6 +10,8 @@
 #ifndef MSGPACK_VERSIONING_HPP
 #define MSGPACK_VERSIONING_HPP
 
+#include "msgpack/cpp_version.hpp"
+
 #if !defined(MSGPACK_DEFAULT_API_VERSION)
 #define MSGPACK_DEFAULT_API_VERSION 1
 #endif
@@ -54,16 +56,16 @@
 
 #define MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns) MSGPACK_DETAIL_PP_CHECK(MSGPACK_DETAIL_PP_NS_ENABLED_PROBE(ns))
 
-#if __cplusplus < 201103L
+#ifdef MSGPACK_USE_CPP03
 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \
     (namespace ns{}; using namespace ns; namespace ns, \
      namespace ns)
 
-#else  // __cplusplus < 201103L
+#else  // MSGPACK_USE_CPP03
 
 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \
     (inline namespace ns, namespace ns)
 
-#endif // __cplusplus < 201103L
+#endif // MSGPACK_USE_CPP03
 
 #endif // MSGPACK_VERSIONING_HPP

include/msgpack/v2/cpp_config_decl.hpp

@@ -11,6 +11,7 @@
 #define MSGPACK_V2_CPP_CONFIG_DECL_HPP
 
 #include "msgpack/v1/cpp_config_decl.hpp"
+#include "msgpack/cpp_version.hpp"
 
 #if defined(MSGPACK_USE_CPP03)
 

include/msgpack/v3/cpp_config_decl.hpp

@@ -11,6 +11,7 @@
 #define MSGPACK_V3_CPP_CONFIG_DECL_HPP
 
 #include "msgpack/v2/cpp_config_decl.hpp"
+#include "msgpack/cpp_version.hpp"
 
 #if defined(MSGPACK_USE_CPP03)
 

include/msgpack/versioning.hpp

@@ -10,6 +10,8 @@
 #ifndef MSGPACK_VERSIONING_HPP
 #define MSGPACK_VERSIONING_HPP
 
+#include "msgpack/cpp_version.hpp"
+
 #if !defined(MSGPACK_DEFAULT_API_VERSION)
 #define MSGPACK_DEFAULT_API_VERSION 3
 #endif
@@ -56,16 +58,16 @@
 
 #define MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns) MSGPACK_DETAIL_PP_CHECK(MSGPACK_DETAIL_PP_NS_ENABLED_PROBE(ns))
 
-#if __cplusplus < 201103L
+#ifdef MSGPACK_USE_CPP03
 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \
     (namespace ns{}; using namespace ns; namespace ns, \
      namespace ns)
 
-#else  // __cplusplus < 201103L
+#else  // MSGPACK_USE_CPP03
 
 #define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_DETAIL_PP_IIF(MSGPACK_DETAIL_PP_IS_NS_ENABLED(ns)) \
     (inline namespace ns, namespace ns)
 
-#endif // __cplusplus < 201103L
+#endif // MSGPACK_USE_CPP03
 
 #endif // MSGPACK_VERSIONING_HPP

msgpack-config.cmake.in

@@ -0,0 +1,9 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+find_dependency(Boost REQUIRED)
+
+include("${CMAKE_CURRENT_LIST_DIR}/msgpackc-cxx-targets.cmake")
+
+check_required_components(msgpackc-cxx)

test-install/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+
+project(test-install LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(msgpack REQUIRED)
+
+add_executable(test-install simple.cpp)
+target_link_libraries(test-install PRIVATE msgpackc-cxx)

test-install/simple.cpp

@@ -0,0 +1,44 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
+
+int main(void)
+{
+    msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
+
+    // serialize the object into the buffer.
+    // any classes that implements write(const char*,size_t) can be a buffer.
+    std::stringstream buffer;
+    msgpack::pack(buffer, src);
+
+    // send the buffer ...
+    buffer.seekg(0);
+
+    // deserialize the buffer into msgpack::object instance.
+    std::string str(buffer.str());
+
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
+
+    // deserialized object is valid during the msgpack::object_handle instance alive.
+    msgpack::object deserialized = oh.get();
+
+    // msgpack::object supports ostream.
+    std::cout << deserialized << std::endl;
+
+    // convert msgpack::object instance into the original type.
+    // if the type is mismatched, it throws msgpack::type_error exception.
+    msgpack::type::tuple<int, bool, std::string> dst;
+    deserialized.convert(dst);
+
+    return 0;
+}

test/CMakeLists.txt

@@ -1,11 +1,6 @@
-FIND_PACKAGE (GTest REQUIRED)
-FIND_PACKAGE (ZLIB REQUIRED)
 FIND_PACKAGE (Threads REQUIRED)
-
+FIND_PACKAGE (ZLIB)
-INCLUDE_DIRECTORIES (
+FIND_PACKAGE (Boost REQUIRED COMPONENTS unit_test_framework system)
-    ${GTEST_INCLUDE_DIRS}
-    ${ZLIB_INCLUDE_DIRS}
-)
 
 LIST (APPEND check_PROGRAMS
     array_ref.cpp
@@ -46,7 +41,7 @@ IF (MSGPACK_USE_X3_PARSE)
     )
 ENDIF ()
 
-IF (MSGPACK_CXX11 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
     LIST (APPEND check_PROGRAMS
         iterator_cpp11.cpp
         msgpack_cpp11.cpp
@@ -80,12 +75,14 @@ FOREACH (source_file ${check_PROGRAMS})
     )
 
     TARGET_LINK_LIBRARIES (${source_file_we}
-        msgpackcxx
+        msgpackc-cxx
-        ${GTEST_BOTH_LIBRARIES}
+        Boost::system
-        ${ZLIB_LIBRARIES}
+        Boost::unit_test_framework
-        ${CMAKE_THREAD_LIBS_INIT}
+        Threads::Threads
+        ZLIB::ZLIB
     )
-    ADD_TEST (${source_file_we} ${source_file_we})
+    ADD_TEST (NAME ${source_file_we} COMMAND ${source_file_we})
+
     IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -Wconversion")
     ENDIF ()
@@ -95,9 +92,9 @@ FOREACH (source_file ${check_PROGRAMS})
 
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
         IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            STRING (REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
         ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+            SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
         ENDIF ()
     ENDIF ()
 ENDFOREACH ()
@@ -106,8 +103,9 @@ ADD_EXECUTABLE (
     multi_file
     multi_file1.cpp multi_file2.cpp
 )
-TARGET_INCLUDE_DIRECTORIES (multi_file
+
-    PRIVATE
+TARGET_LINK_LIBRARIES (multi_file
-        $<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
+    msgpackc-cxx
 )
+
 ADD_TEST (multi_file multi_file)

test/array_ref.cpp

@@ -3,22 +3,14 @@
 #include <string>
 #include <sstream>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_ARRAY_REF
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_vector_char)
 {
     std::vector<char> v;
     v.push_back('a');
@@ -32,14 +24,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_vector_char_const)
 {
     std::vector<char> v;
     v.push_back('a');
@@ -55,14 +47,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_vector_unsigned_char)
 {
     std::vector<unsigned char> v;
     v.push_back('a');
@@ -76,14 +68,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_vector_unsigned_char_const)
 {
     std::vector<unsigned char> v;
     v.push_back('a');
@@ -99,14 +91,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char)
+BOOST_AUTO_TEST_CASE(object_with_zone_vector_char)
 {
     std::vector<char> v;
     v.push_back('a');
@@ -117,14 +109,14 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char_const)
+BOOST_AUTO_TEST_CASE(object_with_zone_vector_char_const)
 {
     std::vector<char> v;
     v.push_back('a');
@@ -137,14 +129,14 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char_const)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char)
+BOOST_AUTO_TEST_CASE(object_with_zone_vector_unsigned_char)
 {
     std::vector<unsigned char> v;
     v.push_back('a');
@@ -155,14 +147,14 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char_const)
+BOOST_AUTO_TEST_CASE(object_with_zone_vector_unsigned_char_const)
 {
     std::vector<unsigned char> v;
     v.push_back('a');
@@ -175,16 +167,16 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char_const)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_array_char)
 {
     std::array<char, 3> v { { 'a', 'b', 'c' } };
 
@@ -195,14 +187,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_array_char_const)
 {
     std::array<char, 3> v { { 'a', 'b', 'c' } };
 
@@ -215,14 +207,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_array_unsigned_char)
 {
     std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
 
@@ -233,14 +225,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
+BOOST_AUTO_TEST_CASE(pack_unpack_convert_array_unsigned_char_const)
 {
     std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
 
@@ -253,14 +245,14 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
     std::string const& str = ss.str();
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
     oh.get().convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char)
+BOOST_AUTO_TEST_CASE(object_with_zone_array_char)
 {
     std::array<char, 3> v { { 'a', 'b', 'c' } };
 
@@ -268,14 +260,14 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char_const)
+BOOST_AUTO_TEST_CASE(object_with_zone_array_char_const)
 {
     std::array<char, 3> v { { 'a', 'b', 'c' } };
 
@@ -285,14 +277,14 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char_const)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char)
+BOOST_AUTO_TEST_CASE(object_with_zone_array_unsigned_char)
 {
     std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
 
@@ -300,14 +292,14 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
-TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char_const)
+BOOST_AUTO_TEST_CASE(object_with_zone_array_unsigned_char_const)
 {
     std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
 
@@ -317,11 +309,11 @@ TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char_const)
     msgpack::zone z;
     msgpack::object obj(ar1, z);
 
-    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(obj.type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
     obj.convert(ar2);
-    EXPECT_TRUE(ar1 == ar2);
+    BOOST_CHECK(ar1 == ar2);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)

test/boost_fusion.cpp

@@ -3,16 +3,8 @@
 #include <iterator>
 #include <cmath>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_BOOST
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -30,7 +22,7 @@ BOOST_FUSION_DEFINE_STRUCT(
     (double, f2)
 )
 
-TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
+BOOST_AUTO_TEST_CASE(fusion_pack_unpack_convert)
 {
     std::stringstream ss;
     mystruct val1;
@@ -41,11 +33,11 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     mystruct val2 = oh.get().as<mystruct>();
-    EXPECT_TRUE(val1.f1 == val2.f1);
+    BOOST_CHECK(val1.f1 == val2.f1);
-    EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
+    BOOST_CHECK(fabs(val2.f2 - val1.f2) <= kEPS);
 }
 
-TEST(MSGPACK_BOOST, object_with_zone_convert)
+BOOST_AUTO_TEST_CASE(object_with_zone_convert)
 {
     mystruct val1;
     val1.f1 = 42;
@@ -53,8 +45,8 @@ TEST(MSGPACK_BOOST, object_with_zone_convert)
     msgpack::zone z;
     msgpack::object obj(val1, z);
     mystruct val2 = obj.as<mystruct>();
-    EXPECT_TRUE(val1.f1 == val2.f1);
+    BOOST_CHECK(val1.f1 == val2.f1);
-    EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
+    BOOST_CHECK(fabs(val2.f2 - val1.f2) <= kEPS);
 }
 
 #if !defined(MSGPACK_USE_CPP03)
@@ -154,7 +146,7 @@ BOOST_FUSION_ADAPT_STRUCT(
 // After MSVC would support Expression SFINAE, remove this guard.
 #if !defined(_MSC_VER)
 
-TEST(MSGPACK_BOOST, pack_convert_no_def_con)
+BOOST_AUTO_TEST_CASE(pack_convert_no_def_con)
 {
     std::stringstream ss;
     mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3));
@@ -163,7 +155,7 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con val2 = oh.get().as<mystruct_no_def_con>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // !defined(_MSC_VER)
@@ -206,7 +198,7 @@ BOOST_FUSION_ADAPT_STRUCT(
 // After MSVC would support Expression SFINAE, remove this guard.
 #if !defined(_MSC_VER)
 
-TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
+BOOST_AUTO_TEST_CASE(pack_convert_no_def_con_def_con)
 {
     std::stringstream ss;
     mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(2), 3);
@@ -215,7 +207,7 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con_def_con val2 = oh.get().as<mystruct_no_def_con_def_con>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // !defined(_MSC_VER)
@@ -224,7 +216,7 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
 
 #include <boost/fusion/include/std_pair.hpp>
 
-TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
+BOOST_AUTO_TEST_CASE(fusion_pack_unpack_convert_pair)
 {
     std::stringstream ss;
     std::pair<bool, int> val1(false, 42);
@@ -233,15 +225,15 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::pair<bool, int>  val2 = oh.get().as<std::pair<bool, int> >();
-    EXPECT_TRUE(val1.first == val2.first);
+    BOOST_CHECK(val1.first == val2.first);
-    EXPECT_TRUE(val1.second == val2.second);
+    BOOST_CHECK(val1.second == val2.second);
 }
 
 #if !defined(MSGPACK_USE_CPP03)
 
 #include <boost/fusion/include/std_tuple.hpp>
 
-TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
+BOOST_AUTO_TEST_CASE(fusion_pack_unpack_convert_tuple)
 {
     std::stringstream ss;
     std::tuple<bool, int> val1(false, 42);
@@ -250,7 +242,7 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::tuple<bool, int> val2 = oh.get().as<std::tuple<bool, int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)

test/boost_optional.cpp

@@ -2,23 +2,14 @@
 #include <sstream>
 #include <iterator>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_BOOST
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-TEST(MSGPACK_BOOST, pack_convert_nil)
+BOOST_AUTO_TEST_CASE(pack_convert_nil)
 {
     std::stringstream ss;
     boost::optional<int> val1;
@@ -27,10 +18,10 @@ TEST(MSGPACK_BOOST, pack_convert_nil)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, pack_convert_int)
+BOOST_AUTO_TEST_CASE(pack_convert_int)
 {
     std::stringstream ss;
     boost::optional<int> val1 = 1;
@@ -39,10 +30,10 @@ TEST(MSGPACK_BOOST, pack_convert_int)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, pack_convert_vector)
+BOOST_AUTO_TEST_CASE(pack_convert_vector)
 {
     typedef boost::optional<std::vector<int> > ovi_t;
     std::stringstream ss;
@@ -57,10 +48,10 @@ TEST(MSGPACK_BOOST, pack_convert_vector)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, pack_convert_vector_optional)
+BOOST_AUTO_TEST_CASE(pack_convert_vector_optional)
 {
     typedef std::vector<boost::optional<int> > voi_t;
     std::stringstream ss;
@@ -73,28 +64,28 @@ TEST(MSGPACK_BOOST, pack_convert_vector_optional)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_nil)
+BOOST_AUTO_TEST_CASE(object_nil)
 {
     boost::optional<int> val1;
     msgpack::object obj(val1);
     boost::optional<int> val2 = obj.as<boost::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_int)
+BOOST_AUTO_TEST_CASE(object_int)
 {
     boost::optional<int> val1 = 1;
     msgpack::object obj(val1);
     boost::optional<int> val2 = obj.as<boost::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 // Compile error as expected
 /*
-  TEST(MSGPACK_BOOST, object_vector)
+  BOOST_AUTO_TEST_CASE(object_vector)
   {
   typedef boost::optional<std::vector<int> > ovi_t;
   ovi_t val1;
@@ -105,29 +96,29 @@ TEST(MSGPACK_BOOST, object_int)
   val1 = v;
   msgpack::object obj(val1);
   ovi_t  val2 = obj.as<ovi_t>();
-  EXPECT_TRUE(val1 == val2);
+  BOOST_CHECK(val1 == val2);
   }
 */
 
-TEST(MSGPACK_BOOST, object_with_zone_nil)
+BOOST_AUTO_TEST_CASE(object_with_zone_nil)
 {
     msgpack::zone z;
     boost::optional<int> val1;
     msgpack::object obj(val1, z);
     boost::optional<int> val2 = obj.as<boost::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_with_zone_int)
+BOOST_AUTO_TEST_CASE(object_with_zone_int)
 {
     msgpack::zone z;
     boost::optional<int> val1 = 1;
     msgpack::object obj(val1, z);
     boost::optional<int> val2 = obj.as<boost::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_with_zone_vector_optional)
+BOOST_AUTO_TEST_CASE(object_with_zone_vector_optional)
 {
     typedef std::vector<boost::optional<int> > voi_t;
     msgpack::zone z;
@@ -137,7 +128,7 @@ TEST(MSGPACK_BOOST, object_with_zone_vector_optional)
     val1[2] = 3;
     msgpack::object obj(val1, z);
     voi_t  val2 = obj.as<voi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #if !defined(MSGPACK_USE_CPP03)
@@ -172,7 +163,7 @@ MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
 } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
 } // msgpack
 
-TEST(MSGPACK_BOOST, pack_convert_no_def_con)
+BOOST_AUTO_TEST_CASE(pack_convert_no_def_con)
 {
     std::stringstream ss;
     boost::optional<no_def_con> val1 = no_def_con(1);
@@ -181,7 +172,7 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     boost::optional<no_def_con> val2 = oh.get().as<boost::optional<no_def_con>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03

test/boost_string_ref.cpp

@@ -2,16 +2,8 @@
 #include <sstream>
 #include <iterator>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_BOOST
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -19,7 +11,7 @@
 
 #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
 
-TEST(MSGPACK_BOOST, pack_convert_string_ref)
+BOOST_AUTO_TEST_CASE(pack_convert_string_ref)
 {
     std::stringstream ss;
     std::string s = "ABC";
@@ -31,26 +23,26 @@ TEST(MSGPACK_BOOST, pack_convert_string_ref)
     std::string const& str = ss.str();
     msgpack::unpack(oh, str.data(), str.size());
     boost::string_ref val2 = oh.get().as<boost::string_ref>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_strinf_ref)
+BOOST_AUTO_TEST_CASE(object_strinf_ref)
 {
     std::string s = "ABC";
     boost::string_ref val1(s);
     msgpack::object obj(val1);
     boost::string_ref val2 = obj.as<boost::string_ref>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_with_zone_string_ref)
+BOOST_AUTO_TEST_CASE(object_with_zone_string_ref)
 {
     msgpack::zone z;
     std::string s = "ABC";
     boost::string_ref val1(s);
     msgpack::object obj(val1, z);
     boost::string_ref val2 = obj.as<boost::string_ref>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53

test/boost_string_view.cpp

@@ -2,16 +2,8 @@
 #include <sstream>
 #include <iterator>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_BOOST
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -19,7 +11,7 @@
 
 #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61
 
-TEST(MSGPACK_BOOST, pack_convert_string_view)
+BOOST_AUTO_TEST_CASE(pack_convert_string_view)
 {
     std::stringstream ss;
     std::string s = "ABC";
@@ -31,26 +23,26 @@ TEST(MSGPACK_BOOST, pack_convert_string_view)
     std::string const& str = ss.str();
     msgpack::unpack(oh, str.data(), str.size());
     boost::string_view val2 = oh.get().as<boost::string_view>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_strinf_view)
+BOOST_AUTO_TEST_CASE(object_strinf_view)
 {
     std::string s = "ABC";
     boost::string_view val1(s);
     msgpack::object obj(val1);
     boost::string_view val2 = obj.as<boost::string_view>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_BOOST, object_with_zone_string_view)
+BOOST_AUTO_TEST_CASE(object_with_zone_string_view)
 {
     msgpack::zone z;
     std::string s = "ABC";
     boost::string_view val1(s);
     msgpack::object obj(val1, z);
     boost::string_view val2 = obj.as<boost::string_view>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61

test/buffer.cpp

@@ -2,40 +2,32 @@
 #include <msgpack/fbuffer.hpp>
 #include <msgpack/zbuffer.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE buffer
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include <string.h>
 
-TEST(buffer, sbuffer)
+BOOST_AUTO_TEST_CASE(sbuffer)
 {
     msgpack::sbuffer sbuf;
     sbuf.write("a", 1);
     sbuf.write("a", 1);
     sbuf.write("a", 1);
 
-    EXPECT_EQ(3ul, sbuf.size());
+    BOOST_CHECK_EQUAL(3ul, sbuf.size());
-    EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
+    BOOST_CHECK( memcmp(sbuf.data(), "aaa", 3) == 0 );
 
     sbuf.clear();
     sbuf.write("a", 1);
     sbuf.write("a", 1);
     sbuf.write("a", 1);
 
-    EXPECT_EQ(3ul, sbuf.size());
+    BOOST_CHECK_EQUAL(3ul, sbuf.size());
-    EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
+    BOOST_CHECK( memcmp(sbuf.data(), "aaa", 3) == 0 );
 }
 
 
-TEST(buffer, vrefbuffer)
+BOOST_AUTO_TEST_CASE(vrefbuffer)
 {
     msgpack::vrefbuffer vbuf;
     vbuf.write("a", 1);
@@ -50,8 +42,8 @@ TEST(buffer, vrefbuffer)
         sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
     }
 
-    EXPECT_EQ(3ul, sbuf.size());
+    BOOST_CHECK_EQUAL(3ul, sbuf.size());
-    EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
+    BOOST_CHECK( memcmp(sbuf.data(), "aaa", 3) == 0 );
 
 
     vbuf.clear();
@@ -67,11 +59,11 @@ TEST(buffer, vrefbuffer)
         sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
     }
 
-    EXPECT_EQ(3ul, sbuf.size());
+    BOOST_CHECK_EQUAL(3ul, sbuf.size());
-    EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
+    BOOST_CHECK( memcmp(sbuf.data(), "aaa", 3) == 0 );
 }
 
-TEST(buffer, zbuffer)
+BOOST_AUTO_TEST_CASE(zbuffer)
 {
     msgpack::zbuffer zbuf;
     zbuf.write("a", 1);
@@ -82,7 +74,7 @@ TEST(buffer, zbuffer)
     zbuf.flush();
 }
 
-TEST(buffer, fbuffer)
+BOOST_AUTO_TEST_CASE(fbuffer)
 {
 #if defined(_MSC_VER)
     FILE* file;
@@ -90,10 +82,10 @@ TEST(buffer, fbuffer)
 #else  // defined(_MSC_VER)
     FILE* file = tmpfile();
 #endif // defined(_MSC_VER)
-    EXPECT_TRUE( file != NULL );
+    BOOST_CHECK( file != NULL );
 
     msgpack::fbuffer fbuf(file);
-    EXPECT_EQ(file, fbuf.file());
+    BOOST_CHECK_EQUAL(file, fbuf.file());
 
     fbuf.write("a", 1);
     fbuf.write("a", 1);
@@ -103,9 +95,9 @@ TEST(buffer, fbuffer)
     rewind(file);
     for (size_t i=0; i < 3; ++i) {
         int ch = fgetc(file);
-        EXPECT_TRUE(ch != EOF);
+        BOOST_CHECK(ch != EOF);
-        EXPECT_EQ('a', static_cast<char>(ch));
+        BOOST_CHECK_EQUAL('a', static_cast<char>(ch));
     }
-    EXPECT_EQ(EOF, fgetc(file));
+    BOOST_CHECK_EQUAL(EOF, fgetc(file));
     fclose(file);
 }

test/buffer_c.cpp

@@ -3,18 +3,10 @@
 #include <msgpack/sbuffer.h>
 #include <msgpack/vrefbuffer.h>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE buffer
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+#include <cstring>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-#include <string.h>
 
 #if defined(unix) || defined(__unix) || defined(__linux__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__) || defined(__HAIKU__)
 #define HAVE_SYS_UIO_H 1
@@ -22,21 +14,21 @@
 #define HAVE_SYS_UIO_H 0
 #endif
 
-TEST(buffer, zbuffer_c)
+BOOST_AUTO_TEST_CASE(zbuffer_c)
 {
     msgpack_zbuffer zbuf;
-    EXPECT_TRUE(msgpack_zbuffer_init(&zbuf, 1, MSGPACK_ZBUFFER_INIT_SIZE));
+    BOOST_CHECK(msgpack_zbuffer_init(&zbuf, 1, MSGPACK_ZBUFFER_INIT_SIZE));
-    EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "a", 1));
-    EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "a", 1));
-    EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "a", 1));
-    EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "", 0));
+    BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "", 0));
 
-    EXPECT_TRUE(msgpack_zbuffer_flush(&zbuf) != NULL);
+    BOOST_CHECK(msgpack_zbuffer_flush(&zbuf) != NULL);
 
     msgpack_zbuffer_destroy(&zbuf);
 }
 
-TEST(buffer, fbuffer_c)
+BOOST_AUTO_TEST_CASE(fbuffer_c)
 {
 #if defined(_MSC_VER)
     FILE* file;
@@ -47,45 +39,45 @@ TEST(buffer, fbuffer_c)
 
     void* fbuf = (void*)file;
 
-    EXPECT_TRUE( file != NULL );
+    BOOST_CHECK( file != NULL );
-    EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_fbuffer_write(fbuf, "a", 1));
-    EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_fbuffer_write(fbuf, "a", 1));
-    EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_fbuffer_write(fbuf, "a", 1));
 
     fflush(file);
     rewind(file);
     for (size_t i=0; i < 3; ++i) {
         int ch = fgetc(file);
-        EXPECT_TRUE(ch != EOF);
+        BOOST_CHECK(ch != EOF);
-        EXPECT_EQ('a', (char) ch);
+        BOOST_CHECK_EQUAL('a', (char) ch);
     }
-    EXPECT_EQ(EOF, fgetc(file));
+    BOOST_CHECK_EQUAL(EOF, fgetc(file));
     fclose(file);
 }
 
-TEST(buffer, sbuffer_c)
+BOOST_AUTO_TEST_CASE(sbuffer_c)
 {
     msgpack_sbuffer *sbuf;
     char *data;
 
     sbuf = msgpack_sbuffer_new();
-    EXPECT_TRUE(sbuf != NULL);
+    BOOST_CHECK(sbuf != NULL);
-    EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "a", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "a", 1));
-    EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "b", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "b", 1));
-    EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "c", 1));
+    BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "c", 1));
-    EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "", 0));
+    BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "", 0));
-    EXPECT_EQ(3U, sbuf->size);
+    BOOST_CHECK_EQUAL(3U, sbuf->size);
-    EXPECT_EQ(0, memcmp(sbuf->data, "abc", 3));
+    BOOST_CHECK_EQUAL(0, memcmp(sbuf->data, "abc", 3));
     data = msgpack_sbuffer_release(sbuf);
-    EXPECT_EQ(0, memcmp(data, "abc", 3));
+    BOOST_CHECK_EQUAL(0, memcmp(data, "abc", 3));
-    EXPECT_EQ(0U, sbuf->size);
+    BOOST_CHECK_EQUAL(0U, sbuf->size);
-    EXPECT_TRUE(sbuf->data == NULL);
+    BOOST_CHECK(sbuf->data == NULL);
 
     free(data);
     msgpack_sbuffer_free(sbuf);
 }
 
-TEST(buffer, vrefbuffer_c)
+BOOST_AUTO_TEST_CASE(vrefbuffer_c)
 {
     const char *raw = "I was about to sail away in a junk,"
                       "When suddenly I heard"
@@ -127,7 +119,7 @@ TEST(buffer, vrefbuffer_c)
         len = (size_t)lseek(fd, 0, SEEK_END);
         lseek(fd, 0, SEEK_SET);
         read(fd, buf, len);
-        EXPECT_EQ(0, memcmp(buf, raw, len));
+        BOOST_CHECK_EQUAL(0, memcmp(buf, raw, len));
         close(fd);
         unlink(filename);
     }
@@ -140,7 +132,7 @@ TEST(buffer, vrefbuffer_c)
             memcpy(buf + len, iov[i].iov_base, iov[i].iov_len);
             len += iov[i].iov_len;
         }
-        EXPECT_EQ(0, memcmp(buf, raw, len));
+        BOOST_CHECK_EQUAL(0, memcmp(buf, raw, len));
     }
 #endif
     free(buf);

test/carray.cpp

@@ -1,19 +1,11 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE carray
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include <sstream>
 
-TEST(carray, pack_unpack_int)
+BOOST_AUTO_TEST_CASE(pack_unpack_int)
 {
     std::stringstream ss;
     int v1[] = { 0, 1 };
@@ -21,29 +13,29 @@ TEST(carray, pack_unpack_int)
     msgpack::pack(ss, v1);
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
     oh.get().convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_int)
+BOOST_AUTO_TEST_CASE(obj_with_zone_int)
 {
     int v1[] = { 0, 1 };
     msgpack::zone z;
 
     msgpack::object o(v1, z);
-    EXPECT_EQ(o.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::ARRAY);
 
     int v2[2];
     o.convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_const_int)
+BOOST_AUTO_TEST_CASE(pack_unpack_const_int)
 {
     std::stringstream ss;
     const int v1[] = { 0, 1 };
@@ -51,29 +43,29 @@ TEST(carray, pack_unpack_const_int)
     msgpack::pack(ss, v1);
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
     oh.get().convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_const_int)
+BOOST_AUTO_TEST_CASE(obj_with_zone_const_int)
 {
     const int v1[] = { 0, 1 };
     msgpack::zone z;
 
     msgpack::object o(v1, z);
-    EXPECT_EQ(o.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::ARRAY);
 
     int v2[2];
     o.convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_string)
+BOOST_AUTO_TEST_CASE(pack_unpack_string)
 {
     std::stringstream ss;
     std::string v1[] = { "ABC", "DEFG" };
@@ -81,29 +73,29 @@ TEST(carray, pack_unpack_string)
     msgpack::pack(ss, v1);
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
 
     std::string v2[2];
     oh.get().convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_string)
+BOOST_AUTO_TEST_CASE(obj_with_zone_string)
 {
     std::string v1[] = { "ABC", "DEFG" };
     msgpack::zone z;
 
     msgpack::object o(v1, z);
-    EXPECT_EQ(o.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::ARRAY);
 
     std::string v2[2];
     o.convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_char)
 {
     std::stringstream ss;
     char v1[] = { 0, 1 };
@@ -111,16 +103,16 @@ TEST(carray, pack_unpack_char)
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
 
     char v2[2];
     msgpack::type::array_ref<char[2]> ar = msgpack::type::make_array_ref(v2);
     oh.get().convert(ar);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_char_as_str)
+BOOST_AUTO_TEST_CASE(pack_unpack_char_as_str)
 {
     std::stringstream ss;
     char v1[2] = { 1, '\0' };
@@ -128,46 +120,46 @@ TEST(carray, pack_unpack_char_as_str)
     msgpack::pack(ss, v1);
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::STR);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
-    EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
+    BOOST_CHECK_EQUAL(oh.get().via.str.size, static_cast<size_t>(1));
 
     char v2[2] = { 2, 3 };
     oh.get().convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_char)
+BOOST_AUTO_TEST_CASE(obj_with_zone_char)
 {
     char v1[] = { 0, 1 };
     msgpack::zone z;
 
     msgpack::object o(msgpack::type::make_array_ref(v1), z);
-    EXPECT_EQ(o.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::ARRAY);
 
     char v2[2];
     msgpack::type::array_ref<char[2]> ar = msgpack::type::make_array_ref(v2);
     o.convert(ar);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_char_as_str)
+BOOST_AUTO_TEST_CASE(obj_with_zone_char_as_str)
 {
     char v1[] = { 1, '\0' };
     msgpack::zone z;
 
     msgpack::object o(v1, z);
-    EXPECT_EQ(o.type, msgpack::type::STR);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::STR);
-    EXPECT_EQ(o.via.str.size, static_cast<size_t>(1));
+    BOOST_CHECK_EQUAL(o.via.str.size, static_cast<size_t>(1));
 
     char v2[2];
     o.convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_unsigned_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_unsigned_char)
 {
     std::stringstream ss;
     unsigned char v1[] = { 0, 1 };
@@ -175,16 +167,16 @@ TEST(carray, pack_unpack_unsigned_char)
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
 
     unsigned char v2[2];
     msgpack::type::array_ref<unsigned char[2]> ar = msgpack::type::make_array_ref(v2);
     oh.get().convert(ar);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_unsigned_char_as_bin)
+BOOST_AUTO_TEST_CASE(pack_unpack_unsigned_char_as_bin)
 {
     std::stringstream ss;
     unsigned char v1[] = { 0, 1 };
@@ -192,46 +184,46 @@ TEST(carray, pack_unpack_unsigned_char_as_bin)
     msgpack::pack(ss, v1);
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
-    EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
+    BOOST_CHECK_EQUAL(oh.get().via.bin.size, static_cast<size_t>(2));
 
     unsigned char v2[2];
     oh.get().convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_unsigned_char)
+BOOST_AUTO_TEST_CASE(obj_with_zone_unsigned_char)
 {
     unsigned char v1[] = { 0, 1 };
     msgpack::zone z;
 
     msgpack::object o(msgpack::type::make_array_ref(v1), z);
-    EXPECT_EQ(o.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::ARRAY);
 
     unsigned char v2[2];
     msgpack::type::array_ref<unsigned char[2]> ar = msgpack::type::make_array_ref(v2);
     o.convert(ar);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_unsigned_char_as_bin)
+BOOST_AUTO_TEST_CASE(obj_with_zone_unsigned_char_as_bin)
 {
     unsigned char v1[] = { 0, 1 };
     msgpack::zone z;
 
     msgpack::object o(v1, z);
-    EXPECT_EQ(o.type, msgpack::type::BIN);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::BIN);
-    EXPECT_EQ(o.via.bin.size, static_cast<size_t>(2));
+    BOOST_CHECK_EQUAL(o.via.bin.size, static_cast<size_t>(2));
 
     unsigned char v2[2];
     o.convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, pack_unpack_signed_char)
+BOOST_AUTO_TEST_CASE(pack_unpack_signed_char)
 {
     std::stringstream ss;
     signed char v1[] = { 0, 1 };
@@ -239,45 +231,45 @@ TEST(carray, pack_unpack_signed_char)
     msgpack::pack(ss, v1);
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
 
     signed char v2[2];
     oh.get().convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
-TEST(carray, obj_with_zone_signed_char)
+BOOST_AUTO_TEST_CASE(obj_with_zone_signed_char)
 {
     signed char v1[] = { 0, 1 };
     msgpack::zone z;
 
     msgpack::object o(v1, z);
-    EXPECT_EQ(o.type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::ARRAY);
 
     signed char v2[2];
     o.convert(v2);
-    EXPECT_EQ(v1[0], v2[0]);
+    BOOST_CHECK_EQUAL(v1[0], v2[0]);
-    EXPECT_EQ(v1[1], v2[1]);
+    BOOST_CHECK_EQUAL(v1[1], v2[1]);
 }
 
 #if MSGPACK_DEFAULT_API_VERSION == 1
 
-TEST(carray, object_as_str)
+BOOST_AUTO_TEST_CASE(object_as_str)
 {
     char v1[] = { 1, '\0' };
 
     msgpack::zone z;
     msgpack::object o(v1);
-    EXPECT_EQ(o.type, msgpack::type::STR);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::STR);
 }
-TEST(carray, object_as_str_const)
+BOOST_AUTO_TEST_CASE(object_as_str_const)
 {
     const char v1[] = { 1, '\0' };
 
     msgpack::zone z;
     msgpack::object o(v1);
-    EXPECT_EQ(o.type, msgpack::type::STR);
+    BOOST_CHECK_EQUAL(o.type, msgpack::type::STR);
 }
 
 #endif // MSGPACK_DEFAULT_API_VERSION == 1

test/cases.cpp

@@ -1,16 +1,8 @@
 #include <msgpack.hpp>
 #include <fstream>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE cases
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 static void feed_file(msgpack::unpacker& pac, const char* path)
 {
@@ -28,7 +20,7 @@ static void feed_file(msgpack::unpacker& pac, const char* path)
     }
 }
 
-TEST(cases, format)
+BOOST_AUTO_TEST_CASE(format)
 {
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
@@ -43,11 +35,11 @@ TEST(cases, format)
     msgpack::object_handle oh;
     while(pac.next(oh)) {
         msgpack::object_handle oh_compact;
-        EXPECT_TRUE( pac_compact.next(oh_compact) );
+        BOOST_CHECK( pac_compact.next(oh_compact) );
-        EXPECT_EQ(oh_compact.get(), oh.get());
+        BOOST_CHECK_EQUAL(oh_compact.get(), oh.get());
     }
 
-    EXPECT_FALSE( pac_compact.next(oh) );
+    BOOST_CHECK( !pac_compact.next(oh) );
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)

test/convert.cpp

@@ -1,15 +1,7 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE convert
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 class enum_member {
 public:
@@ -37,7 +29,7 @@ public:
     MSGPACK_DEFINE(str1, str2);
 };
 
-TEST(convert, compatibility_less)
+BOOST_AUTO_TEST_CASE(compatibility_less)
 {
     std::vector<std::string> src(1);
     src[0] = "kumofs";
@@ -46,13 +38,13 @@ TEST(convert, compatibility_less)
     msgpack::object obj(src, z);
 
     compatibility c;
-    EXPECT_NO_THROW( obj.convert(c) );
+    BOOST_CHECK_NO_THROW( obj.convert(c) );
 
-    EXPECT_EQ("kumofs",  c.str1);
+    BOOST_CHECK_EQUAL("kumofs",  c.str1);
-    EXPECT_EQ("default", c.str2);
+    BOOST_CHECK_EQUAL("default", c.str2);
 }
 
-TEST(convert, compatibility_more)
+BOOST_AUTO_TEST_CASE(compatibility_more)
 {
     std::vector<std::string> src(3);
     src[0] = "kumofs";
@@ -63,13 +55,13 @@ TEST(convert, compatibility_more)
     msgpack::object obj(src, z);
 
     compatibility to;
-    EXPECT_NO_THROW( obj.convert(to) );
+    BOOST_CHECK_NO_THROW( obj.convert(to) );
 
-    EXPECT_EQ("kumofs", to.str1);
+    BOOST_CHECK_EQUAL("kumofs", to.str1);
-    EXPECT_EQ("mpio",   to.str2);
+    BOOST_CHECK_EQUAL("mpio",   to.str2);
 }
 
-TEST(convert, enum_member)
+BOOST_AUTO_TEST_CASE(enum_member_)
 {
     enum_member src;
     src.flag = enum_member::B;
@@ -78,25 +70,25 @@ TEST(convert, enum_member)
     msgpack::object obj(src, z);
 
     enum_member to;
-    EXPECT_NO_THROW( obj.convert(to) );
+    BOOST_CHECK_NO_THROW( obj.convert(to) );
 
-    EXPECT_EQ(enum_member::B, to.flag);
+    BOOST_CHECK_EQUAL(enum_member::B, to.flag);
 }
 
-TEST(convert, return_value_ref)
+BOOST_AUTO_TEST_CASE(return_value_ref)
 {
     msgpack::zone z;
     msgpack::object obj(1, z);
 
     int i;
     int const& j = obj.convert(i);
-    EXPECT_EQ(&i, &j);
+    BOOST_CHECK_EQUAL(&i, &j);
-    EXPECT_EQ(i, j);
+    BOOST_CHECK_EQUAL(i, j);
 }
 
 #if MSGPACK_DEFAULT_API_VERSION == 1 && !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
 
-TEST(convert, return_value_ptr)
+BOOST_AUTO_TEST_CASE(return_value_ptr)
 {
     msgpack::zone z;
     msgpack::object obj(1, z);
@@ -107,28 +99,28 @@ TEST(convert, return_value_ptr)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(obj.convert(&i), &i);
+    BOOST_CHECK_EQUAL(obj.convert(&i), &i);
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(1, i);
+    BOOST_CHECK_EQUAL(1, i);
 }
 
 #endif // MSGPACK_DEFAULT_API_VERSION == 1 && !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
 
-TEST(convert, if_not_nil_nil)
+BOOST_AUTO_TEST_CASE(if_not_nil_nil)
 {
     msgpack::object obj;
     int i;
-    EXPECT_FALSE(obj.convert_if_not_nil(i));
+    BOOST_CHECK(!obj.convert_if_not_nil(i));
 }
 
-TEST(convert, if_not_nil_not_nil)
+BOOST_AUTO_TEST_CASE(if_not_nil_not_nil)
 {
     msgpack::zone z;
     msgpack::object obj(1, z);
 
     int i;
-    EXPECT_TRUE(obj.convert_if_not_nil(i));
+    BOOST_CHECK(obj.convert_if_not_nil(i));
-    EXPECT_EQ(i, 1);
+    BOOST_CHECK_EQUAL(i, 1);
 }

test/fixint.cpp

@@ -1,25 +1,17 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE fixint
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 template <typename T>
 void check_size(size_t size) {
     T v(0);
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, v);
-    EXPECT_EQ(size, sbuf.size());
+    BOOST_CHECK_EQUAL(size, sbuf.size());
 }
 
-TEST(fixint, size)
+BOOST_AUTO_TEST_CASE(size)
 {
     check_size<msgpack::type::fix_int8>(2);
     check_size<msgpack::type::fix_int16>(3);
@@ -45,12 +37,12 @@ void check_convert() {
     T v2;
     oh.get().convert(v2);
 
-    EXPECT_EQ(v1.get(), v2.get());
+    BOOST_CHECK_EQUAL(v1.get(), v2.get());
 
-    EXPECT_EQ(oh.get(), msgpack::object(T(v1.get())));
+    BOOST_CHECK_EQUAL(oh.get(), msgpack::object(T(v1.get())));
 }
 
-TEST(fixint, convert)
+BOOST_AUTO_TEST_CASE(convert)
 {
     check_convert<msgpack::type::fix_int8>();
     check_convert<msgpack::type::fix_int16>();

test/fuzz_unpack_pack_fuzzer_cpp11.cpp

@@ -1,17 +1,9 @@
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE FUZZ_UNPACK_PACK_FUZZER
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include "../fuzz/unpack_pack_fuzzer.cpp"
 
-TEST(FUZZ_UNPACK_PACK_FUZZER, works)
+BOOST_AUTO_TEST_CASE(works)
 {
-  EXPECT_EQ(0, LLVMFuzzerTestOneInput(0, 0));
+  BOOST_CHECK_EQUAL(0, FuzzerTestOneInput(MSGPACK_NULLPTR, 0));
 }

test/iterator_cpp11.cpp

@@ -1,22 +1,12 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE iterator
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-using namespace std;
-
 #if !defined(MSGPACK_USE_CPP03)
 #include <iterator>
 
@@ -25,13 +15,13 @@ using namespace std;
 constexpr unsigned int VECTOR_SIZE = 100;
 constexpr unsigned int MAP_SIZE    = 100;
 
-TEST(iterator, vector)
+BOOST_AUTO_TEST_CASE(vector)
 {
-    using vec_type = vector<unsigned int>;
+    using vec_type = std::vector<unsigned>;
     vec_type vec;
     vec.reserve(VECTOR_SIZE);
     for (unsigned int i = 0; i < VECTOR_SIZE; i++) {
-        vec.push_back(static_cast<unsigned int>(rand()));
+        vec.push_back(static_cast<unsigned>(rand()));
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, vec);
@@ -42,22 +32,22 @@ TEST(iterator, vector)
     auto const& msgarr = oh.get().via.array;
     auto dist = std::distance(begin(msgarr), end(msgarr));
     auto vecSize = vec.size();
-    EXPECT_EQ(static_cast<size_t>(dist), vecSize);
+    BOOST_CHECK_EQUAL(static_cast<size_t>(dist), vecSize);
 
     vec_type::const_iterator correct = std::begin(vec);
     for (auto const& obj : msgarr) {
         auto u64 = *correct;
-        EXPECT_EQ(obj.as<unsigned int>(), u64);
+        BOOST_CHECK_EQUAL(obj.as<unsigned>(), u64);
         ++correct;
     }
 }
 
-TEST(iterator, map)
+BOOST_AUTO_TEST_CASE(map)
 {
-    using map_type = map<unsigned int, unsigned int>;
+    using map_type = std::map<unsigned, unsigned>;
     map_type map;
-    for (unsigned int i = 0; i < MAP_SIZE; i++) {
+    for (unsigned i = 0; i < MAP_SIZE; i++) {
-        map[static_cast<unsigned int>(rand())] = static_cast<unsigned int>(rand());
+        map[static_cast<unsigned>(rand())] = static_cast<unsigned>(rand());
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, map);
@@ -68,13 +58,13 @@ TEST(iterator, map)
     auto const& msgmap = oh.get().via.map;
     auto dist = std::distance(begin(msgmap), end(msgmap));
     auto mapSize = map.size();
-    EXPECT_EQ(static_cast<size_t>(dist), mapSize);
+    BOOST_CHECK_EQUAL(static_cast<size_t>(dist), mapSize);
 
     for (auto const& kv : msgmap) {
-        auto key = kv.key.as<unsigned int>();
+        auto key = kv.key.as<unsigned>();
-        auto val = kv.val.as<unsigned int>();
+        auto val = kv.val.as<unsigned>();
         auto correct = map[key];
-        EXPECT_EQ(val, correct);
+        BOOST_CHECK_EQUAL(val, correct);
     }
 }
 

test/json.cpp

@@ -2,18 +2,10 @@
 #include <fstream>
 #include <sstream>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE json
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+BOOST_AUTO_TEST_CASE(basic_elements)
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-TEST(json, basic_elements)
 {
     typedef std::map<std::string, int> map_s_i;
     map_s_i msi;
@@ -27,10 +19,10 @@ TEST(json, basic_elements)
     msgpack::object o(t1, z);
     std::stringstream ss;
     ss << o;
-    EXPECT_EQ(ss.str(), "[12,-34,1.23,-4.56,true,false,\"ABC\",{\"Hello\":789,\"World\":-789}]");
+    BOOST_CHECK_EQUAL(ss.str(), "[12,-34,1.23,-4.56,true,false,\"ABC\",{\"Hello\":789,\"World\":-789}]");
 }
 
-TEST(json, escape)
+BOOST_AUTO_TEST_CASE(escape)
 {
     std::string s = "\"\\/\b\f\n\r\tabc";
 
@@ -38,10 +30,10 @@ TEST(json, escape)
     msgpack::object o(s, z);
     std::stringstream ss;
     ss << o;
-    EXPECT_EQ(ss.str(), "\"\\\"\\\\\\/\\b\\f\\n\\r\\tabc\"");
+    BOOST_CHECK_EQUAL(ss.str(), "\"\\\"\\\\\\/\\b\\f\\n\\r\\tabc\"");
 }
 
-TEST(json, escape_cc)
+BOOST_AUTO_TEST_CASE(escape_cc)
 {
     std::string s;
     for (int i = 0; i < 0x20; ++i)
@@ -52,5 +44,5 @@ TEST(json, escape_cc)
     msgpack::object o(s, z);
     std::stringstream ss;
     ss << o;
-    EXPECT_EQ(ss.str(), "\"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u007f \"");
+    BOOST_CHECK_EQUAL(ss.str(), "\"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u007f \"");
 }

test/limit.cpp

@@ -1,19 +1,11 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE limit
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include <sstream>
 
-TEST(limit, unpack_array_no_over)
+BOOST_AUTO_TEST_CASE(unpack_array_no_over)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -25,17 +17,17 @@ TEST(limit, unpack_array_no_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(3, 0, 0, 0, 0));
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over)
+BOOST_AUTO_TEST_CASE(unpack_array_over)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -47,17 +39,17 @@ TEST(limit, unpack_array_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_map_no_over)
+BOOST_AUTO_TEST_CASE(unpack_map_no_over)
 {
     std::stringstream ss;
     std::map<int, int> m;
@@ -69,17 +61,17 @@ TEST(limit, unpack_map_no_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 3, 0, 0, 0));
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(msgpack::map_size_overflow const&) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_map_over)
+BOOST_AUTO_TEST_CASE(unpack_map_over)
 {
     std::stringstream ss;
     std::map<int, int> m;
@@ -91,17 +83,17 @@ TEST(limit, unpack_map_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 2, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::map_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_str_no_over)
+BOOST_AUTO_TEST_CASE(unpack_str_no_over)
 {
     std::stringstream ss;
     std::string s("123");
@@ -110,17 +102,17 @@ TEST(limit, unpack_str_no_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 0, 3, 0, 0));
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(msgpack::str_size_overflow const&) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_str_over)
+BOOST_AUTO_TEST_CASE(unpack_str_over)
 {
     std::stringstream ss;
     std::string s("123");
@@ -129,17 +121,17 @@ TEST(limit, unpack_str_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 0, 2, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::str_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_bin_no_over)
+BOOST_AUTO_TEST_CASE(unpack_bin_no_over)
 {
     std::stringstream ss;
     std::vector<char> v;
@@ -151,17 +143,17 @@ TEST(limit, unpack_bin_no_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 0, 0, 3, 0));
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(msgpack::bin_size_overflow const&) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_bin_over)
+BOOST_AUTO_TEST_CASE(unpack_bin_over)
 {
     std::stringstream ss;
     std::vector<char> v;
@@ -173,17 +165,17 @@ TEST(limit, unpack_bin_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 0, 0, 2, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::bin_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_ext_no_over)
+BOOST_AUTO_TEST_CASE(unpack_ext_no_over)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -194,17 +186,17 @@ TEST(limit, unpack_ext_no_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 0, 0, 0, 3+1));
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(msgpack::ext_size_overflow const&) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_ext_over)
+BOOST_AUTO_TEST_CASE(unpack_ext_over)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -215,17 +207,17 @@ TEST(limit, unpack_ext_over)
         msgpack::object_handle oh =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(0, 0, 0, 0, 2+1));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::ext_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_ext_over_32_bit)
+BOOST_AUTO_TEST_CASE(unpack_ext_over_32_bit)
 {
     if (sizeof(std::size_t) == 4) {
         char const buf [] = {
@@ -240,18 +232,18 @@ TEST(limit, unpack_ext_over_32_bit)
             msgpack::object_handle unp;
             msgpack::unpack(unp, buf, sizeof(buf), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                             msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff));
-            EXPECT_TRUE(false);
+            BOOST_CHECK(false);
         }
         catch(msgpack::ext_size_overflow const&) {
-            EXPECT_TRUE(true);
+            BOOST_CHECK(true);
         }
         catch(...) {
-            EXPECT_TRUE(false);
+            BOOST_CHECK(false);
         }
     }
 }
 
-TEST(limit, unpack_ext_no_over_64_bit)
+BOOST_AUTO_TEST_CASE(unpack_ext_no_over_64_bit)
 {
     if (sizeof(std::size_t) == 8) {
         char const buf [] = {
@@ -266,21 +258,21 @@ TEST(limit, unpack_ext_no_over_64_bit)
             msgpack::object_handle unp;
             msgpack::unpack(unp, buf, sizeof(buf), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                             msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff));
-            EXPECT_TRUE(false);
+            BOOST_CHECK(false);
         }
         catch(msgpack::ext_size_overflow const&) {
-            EXPECT_TRUE(false);
+            BOOST_CHECK(false);
         }
         catch(msgpack::insufficient_bytes const&) {
-            EXPECT_TRUE(true);
+            BOOST_CHECK(true);
         }
         catch(...) {
-            EXPECT_TRUE(false);
+            BOOST_CHECK(false);
         }
     }
 }
 
-TEST(limit, unpack_depth_no_over)
+BOOST_AUTO_TEST_CASE(unpack_depth_no_over)
 {
     std::stringstream ss;
     std::vector<int> inner;
@@ -292,17 +284,17 @@ TEST(limit, unpack_depth_no_over)
         msgpack::object_handle unp;
         msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(1, 0, 0, 0, 0, 2));
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(msgpack::depth_size_overflow const&) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_depth_over)
+BOOST_AUTO_TEST_CASE(unpack_depth_over)
 {
     std::stringstream ss;
     std::vector<int> inner;
@@ -314,13 +306,13 @@ TEST(limit, unpack_depth_over)
         msgpack::object_handle unp;
         msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(1, 0, 0, 0, 0, 1));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::depth_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
@@ -328,7 +320,7 @@ TEST(limit, unpack_depth_over)
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(limit, unpack_array_over_cpp11_no_off_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_cpp11_no_off_no_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -340,17 +332,17 @@ TEST(limit, unpack_array_over_cpp11_no_off_no_ref)
         msgpack::object_handle unp =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                             msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over_cpp11_no_off_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_cpp11_no_off_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -363,17 +355,17 @@ TEST(limit, unpack_array_over_cpp11_no_off_ref)
         msgpack::object_handle unp =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                             msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over_cpp11_off_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_cpp11_off_no_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -386,17 +378,17 @@ TEST(limit, unpack_array_over_cpp11_off_no_ref)
         msgpack::object_handle unp =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), off, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                             msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over_cpp11_off_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_cpp11_off_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -410,19 +402,19 @@ TEST(limit, unpack_array_over_cpp11_off_ref)
         msgpack::object_handle unp =
             msgpack::unpack(ss.str().c_str(), ss.str().size(), off, ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                             msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)
 
-TEST(limit, unpack_array_over_no_off_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_no_off_no_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -434,17 +426,17 @@ TEST(limit, unpack_array_over_no_off_no_ref)
         msgpack::object_handle unp;
         msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over_no_off_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_no_off_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -457,17 +449,17 @@ TEST(limit, unpack_array_over_no_off_ref)
         msgpack::object_handle unp;
         msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over_off_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_off_no_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -480,17 +472,17 @@ TEST(limit, unpack_array_over_off_no_ref)
         msgpack::object_handle unp;
         msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpack_array_over_off_ref)
+BOOST_AUTO_TEST_CASE(unpack_array_over_off_ref)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -504,20 +496,20 @@ TEST(limit, unpack_array_over_off_ref)
         msgpack::object_handle unp;
         msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
 // obsolete
 #if MSGPACK_DEFAULT_API_VERSION == 1
 
-TEST(limit, unpack_array_over_off_ref_pointer)
+BOOST_AUTO_TEST_CASE(unpack_array_over_off_ref_pointer)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -538,19 +530,19 @@ TEST(limit, unpack_array_over_off_ref_pointer)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
 #endif // MSGPACK_DEFAULT_API_VERSION == 1
 
-TEST(limit, unpacker_array_over)
+BOOST_AUTO_TEST_CASE(unpacker_array_over)
 {
     std::stringstream ss;
     std::vector<int> v;
@@ -566,30 +558,30 @@ TEST(limit, unpacker_array_over)
         u.buffer_consumed(ss.str().size());
         msgpack::object_handle unp;
         u.next(unp);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch(msgpack::array_size_overflow const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch(...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }
 
-TEST(limit, unpacker_reserve)
+BOOST_AUTO_TEST_CASE(unpacker_reserve)
 {
     msgpack::unpacker u(MSGPACK_NULLPTR, MSGPACK_NULLPTR, MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
                         msgpack::unpack_limit());
     std::size_t original_capacity = u.buffer_capacity();
     u.reserve_buffer(original_capacity + 1u);
-    EXPECT_EQ((original_capacity + COUNTER_SIZE) * 2 - COUNTER_SIZE, u.buffer_capacity());
+    BOOST_CHECK_EQUAL((original_capacity + COUNTER_SIZE) * 2 - COUNTER_SIZE, u.buffer_capacity());
 }
 
-TEST(limit, unpacker_reserve_more_than_twice)
+BOOST_AUTO_TEST_CASE(unpacker_reserve_more_than_twice)
 {
     msgpack::unpacker u(MSGPACK_NULLPTR, MSGPACK_NULLPTR, MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
                         msgpack::unpack_limit());
     std::size_t original_capacity = u.buffer_capacity();
     u.reserve_buffer(original_capacity * 3);
-    EXPECT_EQ((original_capacity + COUNTER_SIZE) * 4 - COUNTER_SIZE, u.buffer_capacity());
+    BOOST_CHECK_EQUAL((original_capacity + COUNTER_SIZE) * 4 - COUNTER_SIZE, u.buffer_capacity());
 }

test/msgpack_basic.cpp

@@ -9,16 +9,9 @@
 #include <list>
 #include <limits>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
+#include <boost/mpl/list.hpp>
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)
@@ -52,109 +45,109 @@ const double kEPS = 1e-10;
             msgpack::pack(sbuf, val1);                      \
             msgpack::object_handle oh =                     \
                 msgpack::unpack(sbuf.data(), sbuf.size());  \
-            EXPECT_EQ(val1, oh.get().as<test_type>());      \
+            BOOST_CHECK_EQUAL(val1, oh.get().as<test_type>());      \
         }                                                   \
     } while(0)
 
-TEST(MSGPACK, simple_buffer_char)
+BOOST_AUTO_TEST_CASE(simple_buffer_char)
 {
     GEN_TEST(char);
 }
 
-TEST(MSGPACK, simple_buffer_signed_char)
+BOOST_AUTO_TEST_CASE(simple_buffer_signed_char)
 {
     GEN_TEST(signed char);
 }
 
-TEST(MSGPACK, simple_buffer_unsigned_char)
+BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_char)
 {
     GEN_TEST(unsigned char);
 }
 
 
-TEST(MSGPACK, simple_buffer_short)
+BOOST_AUTO_TEST_CASE(simple_buffer_short)
 {
     GEN_TEST(short);
 }
 
-TEST(MSGPACK, simple_buffer_int)
+BOOST_AUTO_TEST_CASE(simple_buffer_int)
 {
     GEN_TEST(int);
 }
 
-TEST(MSGPACK, simple_buffer_long)
+BOOST_AUTO_TEST_CASE(simple_buffer_long)
 {
     GEN_TEST(long);
 }
 
-TEST(MSGPACK, simple_buffer_long_long)
+BOOST_AUTO_TEST_CASE(simple_buffer_long_long)
 {
     GEN_TEST(long long);
 }
 
-TEST(MSGPACK, simple_buffer_unsigned_short)
+BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_short)
 {
     GEN_TEST(unsigned short);
 }
 
-TEST(MSGPACK, simple_buffer_unsigned_int)
+BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_int)
 {
     GEN_TEST(unsigned int);
 }
 
-TEST(MSGPACK, simple_buffer_unsigned_long)
+BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_long)
 {
     GEN_TEST(unsigned long);
 }
 
-TEST(MSGPACK, simple_buffer_unsigned_long_long)
+BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_long_long)
 {
     GEN_TEST(unsigned long long);
 }
 
-TEST(MSGPACK, simple_buffer_uint8)
+BOOST_AUTO_TEST_CASE(simple_buffer_uint8)
 {
     GEN_TEST(uint8_t);
 }
 
-TEST(MSGPACK, simple_buffer_uint16)
+BOOST_AUTO_TEST_CASE(simple_buffer_uint16)
 {
     GEN_TEST(uint16_t);
 }
 
-TEST(MSGPACK, simple_buffer_uint32)
+BOOST_AUTO_TEST_CASE(simple_buffer_uint32)
 {
     GEN_TEST(uint32_t);
 }
 
-TEST(MSGPACK, simple_buffer_uint64)
+BOOST_AUTO_TEST_CASE(simple_buffer_uint64)
 {
     GEN_TEST(uint64_t);
 }
 
-TEST(MSGPACK, simple_buffer_int8)
+BOOST_AUTO_TEST_CASE(simple_buffer_int8)
 {
     GEN_TEST(int8_t);
 }
 
-TEST(MSGPACK, simple_buffer_int16)
+BOOST_AUTO_TEST_CASE(simple_buffer_int16)
 {
     GEN_TEST(int16_t);
 }
 
-TEST(MSGPACK, simple_buffer_int32)
+BOOST_AUTO_TEST_CASE(simple_buffer_int32)
 {
     GEN_TEST(int32_t);
 }
 
-TEST(MSGPACK, simple_buffer_int64)
+BOOST_AUTO_TEST_CASE(simple_buffer_int64)
 {
     GEN_TEST(int64_t);
 }
 
 #if !defined(_MSC_VER) || _MSC_VER >=1800
 
-TEST(MSGPACK, simple_buffer_float)
+BOOST_AUTO_TEST_CASE(simple_buffer_float)
 {
     vector<float> v;
     v.push_back(0.0);
@@ -188,11 +181,11 @@ TEST(MSGPACK, simple_buffer_float)
         float val2 = oh.get().as<float>();
 
         if (std::isnan(val1))
-            EXPECT_TRUE(std::isnan(val2));
+            BOOST_CHECK(std::isnan(val2));
         else if (std::isinf(val1))
-            EXPECT_TRUE(std::isinf(val2));
+            BOOST_CHECK(std::isinf(val2));
         else
-            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+            BOOST_CHECK(fabs(val2 - val1) <= kEPS);
     }
 }
 
@@ -206,12 +199,12 @@ struct TypePair {
 };
 } // namespace
 
-template <typename T>
+typedef boost::mpl::list<TypePair<float, signed long long>,
-class IntegerToFloatingPointTest : public testing::Test {
+                         TypePair<float, unsigned long long>,
-};
+                         TypePair<double, signed long long>,
-TYPED_TEST_CASE_P(IntegerToFloatingPointTest);
+                         TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
 
-TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
+BOOST_AUTO_TEST_CASE_TEMPLATE(simple_buffer, TypeParam, IntegerToFloatingPointTestTypes)
 {
     typedef typename TypeParam::float_type float_type;
     typedef typename TypeParam::integer_type integer_type;
@@ -230,24 +223,13 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         float_type val2 = oh.get().as<float_type>();
-        EXPECT_TRUE(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
+        BOOST_CHECK(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
     }
 }
 
-REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest,
-                           simple_buffer);
-
-typedef testing::Types<TypePair<float, signed long long>,
-                       TypePair<float, unsigned long long>,
-                       TypePair<double, signed long long>,
-                       TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance,
-                              IntegerToFloatingPointTest,
-                              IntegerToFloatingPointTestTypes);
-
 #if !defined(_MSC_VER) || _MSC_VER >=1800
 
-TEST(MSGPACK, simple_buffer_double)
+BOOST_AUTO_TEST_CASE(simple_buffer_double)
 {
     vector<double> v;
     v.push_back(0.0);
@@ -285,27 +267,27 @@ TEST(MSGPACK, simple_buffer_double)
         double val2 = oh.get().as<double>();
 
         if (std::isnan(val1))
-            EXPECT_TRUE(std::isnan(val2));
+            BOOST_CHECK(std::isnan(val2));
         else if (std::isinf(val1))
-            EXPECT_TRUE(std::isinf(val2));
+            BOOST_CHECK(std::isinf(val2));
         else
-            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+            BOOST_CHECK(fabs(val2 - val1) <= kEPS);
     }
 }
 
 #endif // !defined(_MSC_VER) || _MSC_VER >=1800
 
-TEST(MSGPACK, simple_buffer_nil)
+BOOST_AUTO_TEST_CASE(simple_buffer_nil)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
     packer.pack_nil();
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::NIL);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::NIL);
 }
 
-TEST(MSGPACK, simple_buffer_true)
+BOOST_AUTO_TEST_CASE(simple_buffer_true)
 {
     msgpack::sbuffer sbuf;
     bool val1 = true;
@@ -313,10 +295,10 @@ TEST(MSGPACK, simple_buffer_true)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     bool val2 = oh.get().as<bool>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK_EQUAL(val1, val2);
 }
 
-TEST(MSGPACK, simple_buffer_false)
+BOOST_AUTO_TEST_CASE(simple_buffer_false)
 {
     msgpack::sbuffer sbuf;
     bool val1 = false;
@@ -324,10 +306,10 @@ TEST(MSGPACK, simple_buffer_false)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     bool val2 = oh.get().as<bool>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK_EQUAL(val1, val2);
 }
 
-TEST(MSGPACK, simple_buffer_fixext1)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext1)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -337,22 +319,22 @@ TEST(MSGPACK, simple_buffer_fixext1)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(1ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(1ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_EQ(2, oh.get().via.ext.data()[0]);
+    BOOST_CHECK_EQUAL(2, oh.get().via.ext.data()[0]);
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(1ul, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(1ul, oh2.get().via.ext.size);
-    EXPECT_EQ(1, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
-    EXPECT_EQ(2, oh2.get().via.ext.data()[0]);
+    BOOST_CHECK_EQUAL(2, oh2.get().via.ext.data()[0]);
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext2)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext2)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -362,24 +344,24 @@ TEST(MSGPACK, simple_buffer_fixext2)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(2ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(2ul, oh.get().via.ext.size);
-    EXPECT_EQ(0, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(0, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(2ul, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(2ul, oh2.get().via.ext.size);
-    EXPECT_EQ(0, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(0, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext4)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext4)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -389,24 +371,24 @@ TEST(MSGPACK, simple_buffer_fixext4)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(4ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(4ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(4ul, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(4ul, oh2.get().via.ext.size);
-    EXPECT_EQ(1, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext8)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext8)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -416,24 +398,24 @@ TEST(MSGPACK, simple_buffer_fixext8)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(8ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(8ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(8ul, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(8ul, oh2.get().via.ext.size);
-    EXPECT_EQ(1, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext16)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext16)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -443,24 +425,24 @@ TEST(MSGPACK, simple_buffer_fixext16)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(16ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(16ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(16ul, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(16ul, oh2.get().via.ext.size);
-    EXPECT_EQ(1, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext_1byte_0)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext_1byte_0)
 {
     std::size_t const size = 0;
     msgpack::sbuffer sbuf;
@@ -469,11 +451,11 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0)
     packer.pack_ext(size, 77);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
 }
 
-TEST(MSGPACK, simple_buffer_fixext_1byte_255)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext_1byte_255)
 {
     std::size_t const size = 255;
     msgpack::sbuffer sbuf;
@@ -485,24 +467,24 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(size, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
-    EXPECT_EQ(77, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext_2byte_256)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext_2byte_256)
 {
     std::size_t const size = 256;
     msgpack::sbuffer sbuf;
@@ -514,24 +496,24 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(size, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
-    EXPECT_EQ(77, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext_2byte_65535)
 {
     std::size_t const size = 65535;
     msgpack::sbuffer sbuf;
@@ -543,24 +525,24 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(size, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
-    EXPECT_EQ(77, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
+BOOST_AUTO_TEST_CASE(simple_buffer_fixext_4byte_65536)
 {
     std::size_t const size = 65536;
     msgpack::sbuffer sbuf;
@@ -572,24 +554,24 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 
     msgpack::sbuffer sbuf2;
     msgpack::pack(sbuf2, oh.get());
     msgpack::object_handle oh2 =
         msgpack::unpack(sbuf2.data(), sbuf2.size());
-    EXPECT_EQ(size, oh2.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
-    EXPECT_EQ(77, oh2.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
 
-    EXPECT_EQ(oh.get(), oh2.get());
+    BOOST_CHECK_EQUAL(oh.get(), oh2.get());
 }
 
-TEST(MSGPACK, simple_buffer_ext_convert)
+BOOST_AUTO_TEST_CASE(simple_buffer_ext_convert)
 {
     std::size_t const size = 65536;
     msgpack::sbuffer sbuf;
@@ -603,13 +585,13 @@ TEST(MSGPACK, simple_buffer_ext_convert)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::ext e;
     oh.get().convert(e);
-    EXPECT_EQ(size, e.size());
+    BOOST_CHECK_EQUAL(size, e.size());
-    EXPECT_EQ(77, e.type());
+    BOOST_CHECK_EQUAL(77, e.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), e.data()));
 }
 
-TEST(MSGPACK, simple_buffer_ext_pack_convert)
+BOOST_AUTO_TEST_CASE(simple_buffer_ext_pack_convert)
 {
     std::size_t const size = 65536;
     msgpack::sbuffer sbuf;
@@ -622,13 +604,13 @@ TEST(MSGPACK, simple_buffer_ext_pack_convert)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::ext val2;
     oh.get().convert(val2);
-    EXPECT_EQ(size, val2.size());
+    BOOST_CHECK_EQUAL(size, val2.size());
-    EXPECT_EQ(77, val2.type());
+    BOOST_CHECK_EQUAL(77, val2.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), val2.data()));
 }
 
-TEST(MSGPACK, simple_buffer_ext_ref_convert)
+BOOST_AUTO_TEST_CASE(simple_buffer_ext_ref_convert)
 {
     std::size_t const size = 65536;
     msgpack::sbuffer sbuf;
@@ -642,13 +624,13 @@ TEST(MSGPACK, simple_buffer_ext_ref_convert)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::ext_ref er;
     oh.get().convert(er);
-    EXPECT_EQ(size, er.size());
+    BOOST_CHECK_EQUAL(size, er.size());
-    EXPECT_EQ(77, er.type());
+    BOOST_CHECK_EQUAL(77, er.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), er.data()));
 }
 
-TEST(MSGPACK, simple_buffer_ext_ref_pack_convert)
+BOOST_AUTO_TEST_CASE(simple_buffer_ext_ref_pack_convert)
 {
     std::size_t const buf_size = 65536;
     std::size_t const data_size = buf_size - 1;
@@ -662,13 +644,13 @@ TEST(MSGPACK, simple_buffer_ext_ref_pack_convert)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::ext_ref val2;
     oh.get().convert(val2);
-    EXPECT_EQ(data_size, val2.size());
+    BOOST_CHECK_EQUAL(data_size, val2.size());
-    EXPECT_EQ(77, val2.type());
+    BOOST_CHECK_EQUAL(77, val2.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(&buf[1], &buf[buf_size], val2.data()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_string)
+BOOST_AUTO_TEST_CASE(simple_buffer_string)
 {
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
@@ -678,65 +660,9 @@ TEST(MSGPACK_STL, simple_buffer_string)
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::STR);
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
         string val2 = oh.get().as<string>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(val1, val2);
+        BOOST_CHECK_EQUAL(val1, val2);
-    }
-}
-
-TEST(MSGPACK_STL, simple_buffer_cstring)
-{
-    for (unsigned int k = 0; k < kLoop; k++) {
-        string val1;
-        for (unsigned int i = 0; i < kElements; i++)
-            val1 += static_cast<char>('a' + rand() % 26);
-        msgpack::sbuffer sbuf;
-        msgpack::pack(sbuf, val1.c_str());
-        msgpack::object_handle oh =
-            msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::STR);
-        string val2 = oh.get().as<string>();
-        EXPECT_EQ(val1.size(), val2.size());
-        EXPECT_EQ(val1, val2);
-    }
-}
-
-TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
-{
-    for (unsigned int k = 0; k < kLoop; k++) {
-        string val1;
-        for (unsigned int i = 0; i < kElements; i++)
-            val1 += static_cast<char>('a' + rand() % 26);
-        msgpack::sbuffer sbuf;
-        char* s = new char[val1.size() + 1];
-        std::memcpy(s, val1.c_str(), val1.size() + 1);
-        msgpack::pack(sbuf, s);
-        delete [] s;
-        msgpack::object_handle oh =
-            msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::STR);
-        string val2 = oh.get().as<string>();
-        EXPECT_EQ(val1.size(), val2.size());
-        EXPECT_EQ(val1, val2);
-    }
-}
-
-TEST(MSGPACK_STL, simple_buffer_wstring)
-{
-    for (unsigned int k = 0; k < kLoop; k++) {
-        wstring val1;
-        for (unsigned int i = 0; i < kElements; i++)
-            val1 += L'a' + rand() % 26;
-        msgpack::sbuffer sbuf;
-        msgpack::pack(sbuf, val1);
-        msgpack::object_handle oh =
-            msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
-        wstring val2 = oh.get().as<wstring>();
-        EXPECT_EQ(val1, val2);
-        wstring val3;
-        oh.get().convert(val3);
-        EXPECT_EQ(val1, val3);
     }
 }

test/msgpack_container.cpp

@@ -12,16 +12,8 @@
 
 #include "test_allocator.hpp"
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_STL
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -46,7 +38,63 @@ struct less : std::less<Key> {
 
 } // namespace test
 
-TEST(MSGPACK_STL, simple_buffer_vector)
+BOOST_AUTO_TEST_CASE(simple_buffer_cstring)
+{
+    for (unsigned int k = 0; k < kLoop; k++) {
+        string val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1 += static_cast<char>('a' + rand() % 26);
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1.c_str());
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
+        string val2 = oh.get().as<string>();
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1, val2);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(simple_buffer_non_const_cstring)
+{
+    for (unsigned int k = 0; k < kLoop; k++) {
+        string val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1 += static_cast<char>('a' + rand() % 26);
+        msgpack::sbuffer sbuf;
+        char* s = new char[val1.size() + 1];
+        std::memcpy(s, val1.c_str(), val1.size() + 1);
+        msgpack::pack(sbuf, s);
+        delete [] s;
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
+        string val2 = oh.get().as<string>();
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1, val2);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(simple_buffer_wstring)
+{
+    for (unsigned int k = 0; k < kLoop; k++) {
+        wstring val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1 += L'a' + rand() % 26;
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1);
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
+        wstring val2 = oh.get().as<wstring>();
+        BOOST_CHECK(val1 == val2);
+        wstring val3;
+        oh.get().convert(val3);
+        BOOST_CHECK(val1 == val3);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(simple_buffer_vector)
 {
     typedef vector<int, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -57,14 +105,14 @@ TEST(MSGPACK_STL, simple_buffer_vector)
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_empty)
 {
     typedef vector<int, test::allocator<int> > type;
     type val1;
@@ -72,13 +120,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_empty)
     msgpack::pack(sbuf, val1);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_char)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_char)
 {
     typedef vector<char, test::allocator<char> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -89,14 +137,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_char)
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_char_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_char_empty)
 {
     typedef vector<char, test::allocator<char> > type;
     type val1;
@@ -104,13 +152,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_char_empty)
     msgpack::pack(sbuf, val1);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_unsigned_char)
 {
     typedef vector<unsigned char, test::allocator<unsigned char> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -121,14 +169,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_unsigned_char_empty)
 {
     typedef vector<unsigned char, test::allocator<unsigned char> > type;
     type val1;
@@ -136,13 +184,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char_empty)
     msgpack::pack(sbuf, val1);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_uint8_t)
 {
     if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
     typedef vector<uint8_t, test::allocator<uint8_t> > type;
@@ -154,14 +202,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+        BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_uint8_t_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_uint8_t_empty)
 {
     if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
     typedef vector<uint8_t, test::allocator<uint8_t> > type;
@@ -170,13 +218,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t_empty)
     msgpack::pack(sbuf, val1);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::BIN);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_bool)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_bool)
 {
     typedef vector<bool, test::allocator<bool> > type;
     type val1;
@@ -186,13 +234,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_bool)
     msgpack::pack(sbuf, val1);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_vector_bool_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_vector_bool_empty)
 {
     typedef vector<bool, test::allocator<bool> > type;
     type val1;
@@ -200,14 +248,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_bool_empty)
     msgpack::pack(sbuf, val1);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
 
-TEST(MSGPACK_STL, simple_buffer_assoc_vector)
+BOOST_AUTO_TEST_CASE(simple_buffer_assoc_vector)
 {
     typedef msgpack::type::assoc_vector<int, int, test::less<int>, test::allocator<std::pair<int, int> > >type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -220,12 +268,12 @@ TEST(MSGPACK_STL, simple_buffer_assoc_vector)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_assoc_vector_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_assoc_vector_empty)
 {
     typedef msgpack::type::assoc_vector<int, int, test::less<int>, test::allocator<std::pair<int, int> > >type;
     type val1;
@@ -234,11 +282,11 @@ TEST(MSGPACK_STL, simple_buffer_assoc_vector_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_map)
+BOOST_AUTO_TEST_CASE(simple_buffer_map)
 {
     typedef map<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -250,12 +298,12 @@ TEST(MSGPACK_STL, simple_buffer_map)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_map_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_map_empty)
 {
     typedef map<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
     type val1;
@@ -264,11 +312,11 @@ TEST(MSGPACK_STL, simple_buffer_map_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_deque)
+BOOST_AUTO_TEST_CASE(simple_buffer_deque)
 {
     typedef deque<int, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -280,12 +328,12 @@ TEST(MSGPACK_STL, simple_buffer_deque)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_deque_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_deque_empty)
 {
     typedef deque<int, test::allocator<int> > type;
     type val1;
@@ -294,11 +342,11 @@ TEST(MSGPACK_STL, simple_buffer_deque_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_list)
+BOOST_AUTO_TEST_CASE(simple_buffer_list)
 {
     typedef list<int, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -310,12 +358,12 @@ TEST(MSGPACK_STL, simple_buffer_list)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type const& val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_list_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_list_empty)
 {
     typedef list<int, test::allocator<int> > type;
     type val1;
@@ -324,11 +372,11 @@ TEST(MSGPACK_STL, simple_buffer_list_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type const& val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_set)
+BOOST_AUTO_TEST_CASE(simple_buffer_set)
 {
     typedef set<int, test::less<int>, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -340,12 +388,12 @@ TEST(MSGPACK_STL, simple_buffer_set)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_set_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_set_empty)
 {
     typedef set<int, test::less<int>, test::allocator<int> > type;
     type val1;
@@ -354,11 +402,11 @@ TEST(MSGPACK_STL, simple_buffer_set_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
-    EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
 }
 
-TEST(MSGPACK_STL, simple_buffer_pair)
+BOOST_AUTO_TEST_CASE(simple_buffer_pair)
 {
     for (unsigned int k = 0; k < kLoop; k++) {
         pair<int, int> val1 = make_pair(rand(), rand());
@@ -367,12 +415,12 @@ TEST(MSGPACK_STL, simple_buffer_pair)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         pair<int, int> val2 = oh.get().as<pair<int, int> >();
-        EXPECT_EQ(val1.first, val2.first);
+        BOOST_CHECK_EQUAL(val1.first, val2.first);
-        EXPECT_EQ(val1.second, val2.second);
+        BOOST_CHECK_EQUAL(val1.second, val2.second);
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_complex_float)
+BOOST_AUTO_TEST_CASE(simple_buffer_complex_float)
 {
     complex<float> val1 = complex<float>(1.23F, 4.56F);
     msgpack::sbuffer sbuf;
@@ -380,14 +428,14 @@ TEST(MSGPACK_STL, simple_buffer_complex_float)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     complex<float> val2 = oh.get().as<complex<float> >();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK_EQUAL(val1, val2);
     complex<float> val3;
     oh.get().convert(val3);
-    EXPECT_EQ(val1, val3);
+    BOOST_CHECK_EQUAL(val1, val3);
 
 }
 
-TEST(MSGPACK_STL, simple_buffer_complex_double)
+BOOST_AUTO_TEST_CASE(simple_buffer_complex_double)
 {
     complex<double> val1 = complex<double>(1.23, 4.56);
     msgpack::sbuffer sbuf;
@@ -395,14 +443,14 @@ TEST(MSGPACK_STL, simple_buffer_complex_double)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     complex<double> val2 = oh.get().as<complex<double> >();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK_EQUAL(val1, val2);
     complex<double> val3;
     oh.get().convert(val3);
-    EXPECT_EQ(val1, val3);
+    BOOST_CHECK_EQUAL(val1, val3);
 
 }
 
-TEST(MSGPACK_STL, simple_buffer_multimap)
+BOOST_AUTO_TEST_CASE(simple_buffer_multimap)
 {
     typedef multimap<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -424,15 +472,15 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
             v1.push_back(make_pair(it->first, it->second));
         for (it = val2.begin(); it != val2.end(); ++it)
             v2.push_back(make_pair(it->first, it->second));
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(v1.size(), v2.size());
+        BOOST_CHECK_EQUAL(v1.size(), v2.size());
         sort(v1.begin(), v1.end());
         sort(v2.begin(), v2.end());
-        EXPECT_TRUE(v1 == v2);
+        BOOST_CHECK(v1 == v2);
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_multimap_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_multimap_empty)
 {
     typedef multimap<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
     type val1;
@@ -441,10 +489,10 @@ TEST(MSGPACK_STL, simple_buffer_multimap_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
-TEST(MSGPACK_STL, simple_buffer_multiset)
+BOOST_AUTO_TEST_CASE(simple_buffer_multiset)
 {
     typedef multiset<int, test::less<int>, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -463,15 +511,15 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
             v1.push_back(*it);
         for (it = val2.begin(); it != val2.end(); ++it)
             v2.push_back(*it);
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(v1.size(), v2.size());
+        BOOST_CHECK_EQUAL(v1.size(), v2.size());
         sort(v1.begin(), v1.end());
         sort(v2.begin(), v2.end());
-        EXPECT_TRUE(v1 == v2);
+        BOOST_CHECK(v1 == v2);
     }
 }
 
-TEST(MSGPACK_STL, simple_buffer_multiset_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_multiset_empty)
 {
     typedef multiset<int, test::less<int>, test::allocator<int> > type;
     type val1;
@@ -480,10 +528,10 @@ TEST(MSGPACK_STL, simple_buffer_multiset_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple)
+BOOST_AUTO_TEST_CASE(simple_tuple)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<bool, std::string, double> val1(true, "kzk", 12.3);
@@ -492,13 +540,13 @@ TEST(MSGPACK_TUPLE, simple_tuple)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::tuple<bool, std::string, double> val2
         = oh.get().as<msgpack::type::tuple<bool, std::string, double> >();
-    EXPECT_EQ(oh.get().via.array.size, 3u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
-    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
-    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
-    EXPECT_EQ(val1.get<2>(), val2.get<2>());
+    BOOST_CHECK_EQUAL(val1.get<2>(), val2.get<2>());
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple_empty)
+BOOST_AUTO_TEST_CASE(simple_tuple_empty)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<> val1;
@@ -506,10 +554,10 @@ TEST(MSGPACK_TUPLE, simple_tuple_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     oh.get().as<msgpack::type::tuple<> >();
-    EXPECT_EQ(oh.get().via.array.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as)
+BOOST_AUTO_TEST_CASE(simple_tuple_grater_than_as)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -518,13 +566,13 @@ TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::tuple<bool, std::string, int, int> val2
         = oh.get().as<msgpack::type::tuple<bool, std::string, int, int> >();
-    EXPECT_EQ(oh.get().via.array.size, 3u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
-    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
-    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
-    EXPECT_EQ(val1.get<2>(), val2.get<2>());
+    BOOST_CHECK_EQUAL(val1.get<2>(), val2.get<2>());
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert)
+BOOST_AUTO_TEST_CASE(simple_tuple_grater_than_convert)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -533,13 +581,13 @@ TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::tuple<bool, std::string, int, int> val2;
     oh.get().convert(val2);
-    EXPECT_EQ(oh.get().via.array.size, 3u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
-    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
-    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
-    EXPECT_EQ(val1.get<2>(), val2.get<2>());
+    BOOST_CHECK_EQUAL(val1.get<2>(), val2.get<2>());
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple_less_than_as)
+BOOST_AUTO_TEST_CASE(simple_tuple_less_than_as)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -548,12 +596,12 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_as)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::tuple<bool, std::string> val2
         = oh.get().as<msgpack::type::tuple<bool, std::string> >();
-    EXPECT_EQ(oh.get().via.array.size, 3u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
-    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
-    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
+BOOST_AUTO_TEST_CASE(simple_tuple_less_than_convert)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -562,12 +610,12 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::tuple<bool, std::string> val2;
     oh.get().convert(val2);
-    EXPECT_EQ(oh.get().via.array.size, 3u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
-    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
-    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
 }
 
-TEST(MSGPACK_TUPLE, simple_tuple_nest)
+BOOST_AUTO_TEST_CASE(simple_tuple_nest)
 {
     msgpack::sbuffer sbuf;
     msgpack::type::tuple<msgpack::type::tuple<> > val1;
@@ -576,7 +624,7 @@ TEST(MSGPACK_TUPLE, simple_tuple_nest)
         msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::type::tuple<msgpack::type::tuple<> > val2;
     oh.get().convert(val2);
-    EXPECT_EQ(oh.get().via.array.size, 1u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 1u);
 }
 
 // TR1
@@ -598,7 +646,7 @@ struct tr1_hash : std::tr1::hash<Key> {
 #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP
 #include <tr1/unordered_map>
 #include "msgpack/adaptor/tr1/unordered_map.hpp"
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_map)
 {
     typedef tr1::unordered_map<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -610,16 +658,16 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
         type::const_iterator it;
         for (it = val1.begin(); it != val1.end(); ++it) {
-            EXPECT_TRUE(val2.find(it->first) != val2.end());
+            BOOST_CHECK(val2.find(it->first) != val2.end());
-            EXPECT_EQ(it->second, val2.find(it->first)->second);
+            BOOST_CHECK_EQUAL(it->second, val2.find(it->first)->second);
         }
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_map_empty)
 {
     typedef tr1::unordered_map<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     type val1;
@@ -628,10 +676,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multimap)
 {
     typedef tr1::unordered_multimap<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -653,15 +701,15 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
             v1.push_back(make_pair(it->first, it->second));
         for (it = val2.begin(); it != val2.end(); ++it)
             v2.push_back(make_pair(it->first, it->second));
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(v1.size(), v2.size());
+        BOOST_CHECK_EQUAL(v1.size(), v2.size());
         sort(v1.begin(), v1.end());
         sort(v2.begin(), v2.end());
-        EXPECT_TRUE(v1 == v2);
+        BOOST_CHECK(v1 == v2);
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multimap_empty)
 {
     typedef tr1::unordered_multimap<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     type val1;
@@ -670,7 +718,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
 #endif
@@ -678,7 +726,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
 #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_SET
 #include <tr1/unordered_set>
 #include "msgpack/adaptor/tr1/unordered_set.hpp"
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_set)
 {
     typedef tr1::unordered_set<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -690,14 +738,14 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
         type::const_iterator it;
         for (it = val1.begin(); it != val1.end(); ++it)
-            EXPECT_TRUE(val2.find(*it) != val2.end());
+            BOOST_CHECK(val2.find(*it) != val2.end());
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_set_empty)
 {
     typedef tr1::unordered_set<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
     type val1;
@@ -706,10 +754,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multiset)
 {
     typedef tr1::unordered_multiset<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -728,15 +776,15 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
             v1.push_back(*it);
         for (it = val2.begin(); it != val2.end(); ++it)
             v2.push_back(*it);
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(v1.size(), v2.size());
+        BOOST_CHECK_EQUAL(v1.size(), v2.size());
         sort(v1.begin(), v1.end());
         sort(v2.begin(), v2.end());
-        EXPECT_TRUE(v1 == v2);
+        BOOST_CHECK(v1 == v2);
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multiset_empty)
 {
     typedef tr1::unordered_multiset<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
     type val1;
@@ -745,7 +793,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
 #endif
@@ -767,7 +815,7 @@ struct hash : std::hash<Key> {
 #ifdef MSGPACK_HAS_STD_UNORDERED_MAP
 #include <unordered_map>
 #include "msgpack/adaptor/tr1/unordered_map.hpp"
-TEST(MSGPACK_TR1, simple_buffer_unordered_map)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map)
 {
     typedef unordered_map<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -779,16 +827,16 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
         type::const_iterator it;
         for (it = val1.begin(); it != val1.end(); ++it) {
-            EXPECT_TRUE(val2.find(it->first) != val2.end());
+            BOOST_CHECK(val2.find(it->first) != val2.end());
-            EXPECT_EQ(it->second, val2.find(it->first)->second);
+            BOOST_CHECK_EQUAL(it->second, val2.find(it->first)->second);
         }
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_map_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map_empty)
 {
     typedef unordered_map<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     type val1;
@@ -797,10 +845,10 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap)
 {
     typedef unordered_multimap<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -822,15 +870,15 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
             v1.push_back(make_pair(it->first, it->second));
         for (it = val2.begin(); it != val2.end(); ++it)
             v2.push_back(make_pair(it->first, it->second));
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(v1.size(), v2.size());
+        BOOST_CHECK_EQUAL(v1.size(), v2.size());
         sort(v1.begin(), v1.end());
         sort(v2.begin(), v2.end());
-        EXPECT_TRUE(v1 == v2);
+        BOOST_CHECK(v1 == v2);
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap_empty)
 {
     typedef unordered_multimap<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
     type val1;
@@ -839,7 +887,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
 #endif
@@ -848,7 +896,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
 
 #include <unordered_set>
 #include "msgpack/adaptor/tr1/unordered_set.hpp"
-TEST(MSGPACK_TR1, simple_buffer_unordered_set)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set)
 {
     typedef unordered_set<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -860,14 +908,14 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         type val2 = oh.get().as<type>();
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
         type::const_iterator it;
         for (it = val1.begin(); it != val1.end(); ++it)
-            EXPECT_TRUE(val2.find(*it) != val2.end());
+            BOOST_CHECK(val2.find(*it) != val2.end());
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_set_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set_empty)
 {
     typedef unordered_set<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
     type val1;
@@ -876,10 +924,10 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset)
 {
     typedef unordered_multiset<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
     for (unsigned int k = 0; k < kLoop; k++) {
@@ -898,15 +946,15 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
             v1.push_back(*it);
         for (it = val2.begin(); it != val2.end(); ++it)
             v2.push_back(*it);
-        EXPECT_EQ(val1.size(), val2.size());
+        BOOST_CHECK_EQUAL(val1.size(), val2.size());
-        EXPECT_EQ(v1.size(), v2.size());
+        BOOST_CHECK_EQUAL(v1.size(), v2.size());
         sort(v1.begin(), v1.end());
         sort(v2.begin(), v2.end());
-        EXPECT_TRUE(v1 == v2);
+        BOOST_CHECK(v1 == v2);
     }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_multiset_empty)
+BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset_empty)
 {
     typedef unordered_multiset<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
     type val1;
@@ -915,7 +963,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset_empty)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     type val2 = oh.get().as<type>();
-    EXPECT_EQ(val1.size(), val2.size());
+    BOOST_CHECK_EQUAL(val1.size(), val2.size());
 }
 
 #endif

test/msgpack_cpp17.cpp

@@ -1,32 +1,24 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_CPP17
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-// To avoid link error
+// For C++ standards lower than C++17
-TEST(MSGPACK_CPP17, dummy)
+BOOST_AUTO_TEST_CASE(dummy)
 {
 }
 
-#if !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703
+#if MSGPACK_CPP_VERSION >= 201703
 
 // C++17
 
 #if MSGPACK_HAS_INCLUDE(<optional>)
 
-TEST(MSGPACK_CPP17, optional_pack_convert_nil)
+BOOST_AUTO_TEST_CASE(optional_pack_convert_nil)
 {
     std::stringstream ss;
     std::optional<int> val1;
@@ -35,10 +27,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_pack_convert_int)
+BOOST_AUTO_TEST_CASE(optional_pack_convert_int)
 {
     std::stringstream ss;
     std::optional<int> val1 = 1;
@@ -47,10 +39,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_pack_convert_vector)
+BOOST_AUTO_TEST_CASE(optional_pack_convert_vector)
 {
     typedef std::optional<std::vector<int> > ovi_t;
     std::stringstream ss;
@@ -65,10 +57,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
+BOOST_AUTO_TEST_CASE(optional_pack_convert_vector_optional)
 {
     typedef std::vector<std::optional<int> > voi_t;
     std::stringstream ss;
@@ -81,28 +73,28 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_object_nil)
+BOOST_AUTO_TEST_CASE(optional_object_nil)
 {
     std::optional<int> val1;
     msgpack::object obj(val1);
     std::optional<int> val2 = obj.as<std::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_object_int)
+BOOST_AUTO_TEST_CASE(optional_object_int)
 {
     std::optional<int> val1 = 1;
     msgpack::object obj(val1);
     std::optional<int> val2 = obj.as<std::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 // Compile error as expected
 /*
-  TEST(MSGPACK_CPP17, optional_object_vector)
+  BOOST_AUTO_TEST_CASE(optional_object_vector)
   {
   typedef std::optional<std::vector<int> > ovi_t;
   ovi_t val1;
@@ -113,29 +105,29 @@ TEST(MSGPACK_CPP17, optional_object_int)
   val1 = v;
   msgpack::object obj(val1);
   ovi_t  val2 = obj.as<ovi_t>();
-  EXPECT_TRUE(val1 == val2);
+  BOOST_CHECK(val1 == val2);
   }
 */
 
-TEST(MSGPACK_CPP17, optional_object_with_zone_nil)
+BOOST_AUTO_TEST_CASE(optional_object_with_zone_nil)
 {
     msgpack::zone z;
     std::optional<int> val1;
     msgpack::object obj(val1, z);
     std::optional<int> val2 = obj.as<std::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_object_with_zone_int)
+BOOST_AUTO_TEST_CASE(optional_object_with_zone_int)
 {
     msgpack::zone z;
     std::optional<int> val1 = 1;
     msgpack::object obj(val1, z);
     std::optional<int> val2 = obj.as<std::optional<int> >();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, optional_object_with_zone_vector_optional)
+BOOST_AUTO_TEST_CASE(optional_object_with_zone_vector_optional)
 {
     typedef std::vector<std::optional<int> > voi_t;
     msgpack::zone z;
@@ -145,7 +137,7 @@ TEST(MSGPACK_CPP17, optional_object_with_zone_vector_optional)
     val1[2] = 3;
     msgpack::object obj(val1, z);
     voi_t  val2 = obj.as<voi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 struct no_def_con {
@@ -180,7 +172,7 @@ struct as<no_def_con> {
 } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
 } // msgpack
 
-TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
+BOOST_AUTO_TEST_CASE(optional_pack_convert_no_def_con)
 {
     std::stringstream ss;
     std::optional<no_def_con> val1 = no_def_con(1);
@@ -189,14 +181,14 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // MSGPACK_HAS_INCLUDE(<optional>)
 
 #if MSGPACK_HAS_INCLUDE(<string_view>)
 
-TEST(MSGPACK_CPP17, string_view_pack_convert)
+BOOST_AUTO_TEST_CASE(string_view_pack_convert)
 {
     std::stringstream ss;
     std::string s = "ABC";
@@ -208,31 +200,31 @@ TEST(MSGPACK_CPP17, string_view_pack_convert)
     msgpack::object_handle oh;
     msgpack::unpack(oh, str.data(), str.size());
     std::string_view val2 = oh.get().as<std::string_view>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, string_view_object)
+BOOST_AUTO_TEST_CASE(string_view_object)
 {
     std::string s = "ABC";
     std::string_view val1(s);
     msgpack::object obj(val1);
     std::string_view val2 = obj.as<std::string_view>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, string_view_object_with_zone)
+BOOST_AUTO_TEST_CASE(string_view_object_with_zone)
 {
     msgpack::zone z;
     std::string s = "ABC";
     std::string_view val1(s);
     msgpack::object obj(val1, z);
     std::string_view val2 = obj.as<std::string_view>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
 #endif // MSGPACK_HAS_INCLUDE(<string_view>)
 
-TEST(MSGPACK_CPP17, byte_pack_convert)
+BOOST_AUTO_TEST_CASE(byte_pack_convert)
 {
     std::stringstream ss;
     std::byte val1{0xff};
@@ -243,27 +235,27 @@ TEST(MSGPACK_CPP17, byte_pack_convert)
     std::string const& str = ss.str();
     msgpack::unpack(oh, str.data(), str.size());
     std::byte val2 = oh.get().as<std::byte>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, byte_object)
+BOOST_AUTO_TEST_CASE(byte_object)
 {
     std::byte val1{0x00};
     msgpack::object obj(val1);
     std::byte val2 = obj.as<std::byte>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, byte_object_with_zone)
+BOOST_AUTO_TEST_CASE(byte_object_with_zone)
 {
     msgpack::zone z;
     std::byte val1{80};
     msgpack::object obj(val1, z);
     std::byte val2 = obj.as<std::byte>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, vector_byte_pack_convert)
+BOOST_AUTO_TEST_CASE(vector_byte_pack_convert)
 {
     std::stringstream ss;
     std::vector<std::byte> val1{
@@ -274,18 +266,18 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
     std::string const& str = ss.str();
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
-    EXPECT_EQ(str.size(), sizeof(packed));
+    BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(str[i], packed[i]);
+        BOOST_CHECK_EQUAL(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
     msgpack::unpack(oh, str.data(), str.size());
     std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, vector_byte_object)
+BOOST_AUTO_TEST_CASE(vector_byte_object)
 {
     std::vector<std::byte> val1{
         std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
@@ -295,10 +287,10 @@ TEST(MSGPACK_CPP17, vector_byte_object)
     msgpack::object obj(val1);
 
     std::vector<std::byte> val2 = obj.as<std::vector<std::byte>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, vector_byte_object_with_zone)
+BOOST_AUTO_TEST_CASE(vector_byte_object_with_zone)
 {
     msgpack::zone z;
     std::vector<std::byte> val1{
@@ -307,10 +299,10 @@ TEST(MSGPACK_CPP17, vector_byte_object_with_zone)
     msgpack::object obj(val1, z);
 
     std::vector<std::byte> val2 = obj.as<std::vector<std::byte>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(MSGPACK_CPP17, array_byte_pack_convert)
+BOOST_AUTO_TEST_CASE(array_byte_pack_convert)
 {
     std::stringstream ss;
     std::array<std::byte, 5> val1{
@@ -321,27 +313,27 @@ TEST(MSGPACK_CPP17, array_byte_pack_convert)
     std::string const& str = ss.str();
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
-    EXPECT_EQ(str.size(), sizeof(packed));
+    BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(str[i], packed[i]);
+        BOOST_CHECK_EQUAL(str[i], packed[i]);
     }
 
     {
         msgpack::object_handle oh;
         msgpack::unpack(oh, str.data(), str.size());
         auto val2 = oh.get().as<std::array<std::byte, 5>>();
-        EXPECT_EQ(val1, val2);
+        BOOST_CHECK(val1 == val2);
     }
     {
         msgpack::object_handle oh;
         msgpack::unpack(oh, str.data(), str.size());
-        EXPECT_THROW((oh.get().as<std::array<std::byte, 0>>()),    msgpack::type_error);
+        BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 0>>()),    msgpack::type_error);
-        EXPECT_THROW((oh.get().as<std::array<std::byte, 1>>()),    msgpack::type_error);
+        BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 1>>()),    msgpack::type_error);
-        EXPECT_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
+        BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
     }
 }
 
-TEST(MSGPACK_CPP17, array_byte_object)
+BOOST_AUTO_TEST_CASE(array_byte_object)
 {
     std::array<std::byte, 5> val1{
         std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
@@ -351,14 +343,14 @@ TEST(MSGPACK_CPP17, array_byte_object)
     msgpack::object obj(val1);
 
     auto val2 = obj.as<std::array<std::byte, 5>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 
-    EXPECT_THROW((obj.as<std::array<std::byte, 0>>()),    msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 0>>()),    msgpack::type_error);
-    EXPECT_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
-    EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
 }
 
-TEST(MSGPACK_CPP17, array_byte_object_with_zone)
+BOOST_AUTO_TEST_CASE(array_byte_object_with_zone)
 {
     msgpack::zone z;
     std::array<std::byte, 5> val1{
@@ -367,14 +359,14 @@ TEST(MSGPACK_CPP17, array_byte_object_with_zone)
     msgpack::object obj(val1, z);
 
     auto val2 = obj.as<std::array<std::byte, 5>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 
-    EXPECT_THROW((obj.as<std::array<std::byte, 0>>()),    msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 0>>()),    msgpack::type_error);
-    EXPECT_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
-    EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
 }
 
-TEST(MSGPACK_CPP17, array_byte_empty_pack_convert)
+BOOST_AUTO_TEST_CASE(array_byte_empty_pack_convert)
 {
     std::stringstream ss;
     std::array<std::byte, 0> val1{};
@@ -383,26 +375,26 @@ TEST(MSGPACK_CPP17, array_byte_empty_pack_convert)
     std::string const& str = ss.str();
 
     char packed[] = { char(0xc4), char(0x00) };
-    EXPECT_EQ(str.size(), sizeof(packed));
+    BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(str[i], packed[i]);
+        BOOST_CHECK_EQUAL(str[i], packed[i]);
     }
 
     {
         msgpack::object_handle oh;
         msgpack::unpack(oh, str.data(), str.size());
         auto val2 = oh.get().as<std::array<std::byte, 0>>();
-        EXPECT_EQ(val1, val2);
+        BOOST_CHECK(val1 == val2);
     }
     {
         msgpack::object_handle oh;
         msgpack::unpack(oh, str.data(), str.size());
-        EXPECT_THROW((oh.get().as<std::array<std::byte, 1>>()),    msgpack::type_error);
+        BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 1>>()),    msgpack::type_error);
-        EXPECT_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
+        BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
     }
 }
 
-TEST(MSGPACK_CPP17, array_byte_empty_object)
+BOOST_AUTO_TEST_CASE(array_byte_empty_object)
 {
     std::array<std::byte, 0> val1{};
 
@@ -410,26 +402,26 @@ TEST(MSGPACK_CPP17, array_byte_empty_object)
     msgpack::object obj(val1);
 
     auto val2 = obj.as<std::array<std::byte, 0>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 
-    EXPECT_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
-    EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
 }
 
-TEST(MSGPACK_CPP17, array_byte_empty_object_with_zone)
+BOOST_AUTO_TEST_CASE(array_byte_empty_object_with_zone)
 {
     msgpack::zone z;
     std::array<std::byte, 0> val1{};
     msgpack::object obj(val1, z);
 
     auto val2 = obj.as<std::array<std::byte, 0>>();
-    EXPECT_EQ(val1, val2);
+    BOOST_CHECK(val1 == val2);
 
-    EXPECT_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()),    msgpack::type_error);
-    EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
+    BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
 }
 
-TEST(MSGPACK_CPP17, carray_byte_pack_convert)
+BOOST_AUTO_TEST_CASE(carray_byte_pack_convert)
 {
     std::stringstream ss;
     std::byte val1[] = {
@@ -440,9 +432,9 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
     std::string const& str = ss.str();
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
-    EXPECT_EQ(str.size(), sizeof(packed));
+    BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(str[i], packed[i]);
+        BOOST_CHECK_EQUAL(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
@@ -450,11 +442,11 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
     std::byte val2[sizeof(val1)];
     oh.get().convert(val2);
     for (size_t i = 0; i != sizeof(val1); ++i) {
-        EXPECT_EQ(val1[i], val2[i]);
+        BOOST_CHECK(val1[i] == val2[i]);
     }
 }
 
-TEST(MSGPACK_CPP17, carray_byte_object_with_zone)
+BOOST_AUTO_TEST_CASE(carray_byte_object_with_zone)
 {
     msgpack::zone z;
     std::byte val1[] = {
@@ -465,8 +457,8 @@ TEST(MSGPACK_CPP17, carray_byte_object_with_zone)
     std::byte val2[sizeof(val1)];
     obj.convert(val2);
     for (size_t i = 0; i != sizeof(val1); ++i) {
-        EXPECT_EQ(val1[i], val2[i]);
+        BOOST_CHECK(val1[i] == val2[i]);
     }
 }
 
-#endif // !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703
+#endif // MSGPACK_CPP_VERSION >= 201703

test/msgpack_cpp20.cpp

@@ -1,26 +1,19 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_CPP20
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-// To avoid link error
+// For C++ standards lower than C++20
-TEST(MSGPACK_CPP20, dummy)
+BOOST_AUTO_TEST_CASE(dummy)
 {
 }
 
-#if !defined(MSGPACK_USE_CPP03) && __cplusplus > 201703
+// Some compilers still do not set the corresponding macro to 202002
+#if MSGPACK_CPP_VERSION > 201703
 
 #if MSGPACK_HAS_INCLUDE(<span>)
 
@@ -48,7 +41,7 @@ bool operator==(const std::vector<Byte>& lhs, const std::span<const Byte>& rhs)
 }
 
 #define MSGPACK_TEST_SPAN_BYTE_PACK_CONVERT(byte_t, display_name)                                               \
-    TEST(MSGPACK_CPP20, span_##display_name##_pack_convert)                                                     \
+    BOOST_AUTO_TEST_CASE(span_##display_name##_pack_convert)                                                    \
     {                                                                                                           \
         std::stringstream ss;                                                                                   \
         byte_t raw_data[] = {                                                                                   \
@@ -60,25 +53,25 @@ bool operator==(const std::vector<Byte>& lhs, const std::span<const Byte>& rhs)
         std::string const& str = ss.str();                                                                      \
                                                                                                                 \
         char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) }; \
-        EXPECT_EQ(str.size(), sizeof(packed));                                                                  \
+        BOOST_CHECK_EQUAL(str.size(), sizeof(packed));                                                          \
         for (size_t i = 0; i != sizeof(packed); ++i) {                                                          \
-            EXPECT_EQ(str[i], packed[i]);                                                                       \
+            BOOST_CHECK_EQUAL(str[i], packed[i]);                                                               \
         }                                                                                                       \
                                                                                                                 \
         msgpack::object_handle oh;                                                                              \
         msgpack::unpack(oh, str.data(), str.size());                                                            \
         {                                                                                                       \
             auto val2 = oh.get().as<std::vector<byte_t>>();                                                     \
-            EXPECT_TRUE(val1 == val2);                                                                          \
+            BOOST_CHECK(val1 == val2);                                                                          \
         }                                                                                                       \
         {                                                                                                       \
             auto val2 = oh.get().as<std::span<const byte_t>>();                                                 \
-            EXPECT_TRUE(val1 == val2);                                                                          \
+            BOOST_CHECK(val1 == val2);                                                                          \
         }                                                                                                       \
     }                                                                                                           \
 
 #define MSGPACK_TEST_SPAN_BYTE_OBJECT(byte_t, display_name)                                                     \
-    TEST(MSGPACK_CPP20, span_##display_name##_object)                                                           \
+    BOOST_AUTO_TEST_CASE(span_##display_name##_object)                                                          \
     {                                                                                                           \
         byte_t raw_data[] = {                                                                                   \
             (byte_t)(0x01), (byte_t)(0x02), (byte_t)(0x7f), (byte_t)(0x80), (byte_t)(0xff)                      \
@@ -90,16 +83,16 @@ bool operator==(const std::vector<Byte>& lhs, const std::span<const Byte>& rhs)
                                                                                                                 \
         {                                                                                                       \
             auto val2 = obj.as<std::vector<byte_t>>();                                                          \
-            EXPECT_TRUE(val1 == val2);                                                                          \
+            BOOST_CHECK(val1 == val2);                                                                          \
         }                                                                                                       \
         {                                                                                                       \
             auto val2 = obj.as<std::span<const byte_t>>();                                                      \
-            EXPECT_TRUE(val1 == val2);                                                                          \
+            BOOST_CHECK(val1 == val2);                                                                          \
         }                                                                                                       \
     }                                                                                                           \
 
 #define MSGPACK_TEST_SPAN_BYTE_OBJECT_WITH_ZONE(byte_t, display_name)                                           \
-    TEST(MSGPACK_CPP20, span_##display_name##_object_with_zone)                                                 \
+    BOOST_AUTO_TEST_CASE(span_##display_name##_object_with_zone)                                                \
     {                                                                                                           \
         msgpack::zone z;                                                                                        \
         byte_t raw_data[] = {                                                                                   \
@@ -111,11 +104,11 @@ bool operator==(const std::vector<Byte>& lhs, const std::span<const Byte>& rhs)
                                                                                                                 \
         {                                                                                                       \
             auto val2 = obj.as<std::vector<byte_t>>();                                                          \
-            EXPECT_TRUE(val1 == val2);                                                                          \
+            BOOST_CHECK(val1 == val2);                                                                          \
         }                                                                                                       \
         {                                                                                                       \
             auto val2 = obj.as<std::span<const byte_t>>();                                                      \
-            EXPECT_TRUE(val1 == val2);                                                                          \
+            BOOST_CHECK(val1 == val2);                                                                          \
         }                                                                                                       \
     }                                                                                                           \
 
@@ -135,4 +128,4 @@ MSGPACK_TEST_SPAN_BYTE(unsigned char, unsigned_char)
 
 #endif // MSGPACK_HAS_INCLUDE(<span>)
 
-#endif // !defined(MSGPACK_USE_CPP03) && __cplusplus > 201703
+#endif // MSGPACK_CPP_VERSION > 201703

test/msgpack_stream.cpp

@@ -9,16 +9,8 @@
 #include <list>
 #include <limits>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -55,7 +47,7 @@ const unsigned int kLoop = 1000;
                 msgpack::object obj = oh.get();                         \
                 vec_type::value_type val;                               \
                 obj.convert(val);                                       \
-                EXPECT_EQ(*it, val);                                    \
+                BOOST_CHECK_EQUAL(*it, val);                            \
                 ++it;                                                   \
             }                                                           \
             p += sz;                                                    \
@@ -64,97 +56,97 @@ const unsigned int kLoop = 1000;
         ;                                                               \
     }
 
-TEST(MSGPACK, stream_char)
+BOOST_AUTO_TEST_CASE(stream_char)
 {
     GEN_TEST_STREAM(char);
 }
 
-TEST(MSGPACK, stream_signed_char)
+BOOST_AUTO_TEST_CASE(stream_signed_char)
 {
     GEN_TEST_STREAM(signed char);
 }
 
-TEST(MSGPACK, stream_unsigned_char)
+BOOST_AUTO_TEST_CASE(stream_unsigned_char)
 {
     GEN_TEST_STREAM(unsigned char);
 }
 
-TEST(MSGPACK, stream_short)
+BOOST_AUTO_TEST_CASE(stream_short)
 {
     GEN_TEST_STREAM(short);
 }
 
-TEST(MSGPACK, stream_int)
+BOOST_AUTO_TEST_CASE(stream_int)
 {
     GEN_TEST_STREAM(int);
 }
 
-TEST(MSGPACK, stream_long)
+BOOST_AUTO_TEST_CASE(stream_long)
 {
     GEN_TEST_STREAM(long);
 }
 
-TEST(MSGPACK, stream_long_long)
+BOOST_AUTO_TEST_CASE(stream_long_long)
 {
     GEN_TEST_STREAM(long long);
 }
 
-TEST(MSGPACK, stream_unsigned_short)
+BOOST_AUTO_TEST_CASE(stream_unsigned_short)
 {
     GEN_TEST_STREAM(unsigned short);
 }
 
-TEST(MSGPACK, stream_unsigned_int)
+BOOST_AUTO_TEST_CASE(stream_unsigned_int)
 {
     GEN_TEST_STREAM(unsigned int);
 }
 
-TEST(MSGPACK, stream_unsigned_long)
+BOOST_AUTO_TEST_CASE(stream_unsigned_long)
 {
     GEN_TEST_STREAM(unsigned long);
 }
 
-TEST(MSGPACK, stream_unsigned_long_long)
+BOOST_AUTO_TEST_CASE(stream_unsigned_long_long)
 {
     GEN_TEST_STREAM(unsigned long long);
 }
 
-TEST(MSGPACK, stream_uint8)
+BOOST_AUTO_TEST_CASE(stream_uint8)
 {
     GEN_TEST_STREAM(uint8_t);
 }
 
-TEST(MSGPACK, stream_uint16)
+BOOST_AUTO_TEST_CASE(stream_uint16)
 {
     GEN_TEST_STREAM(uint16_t);
 }
 
-TEST(MSGPACK, stream_uint32)
+BOOST_AUTO_TEST_CASE(stream_uint32)
 {
     GEN_TEST_STREAM(uint32_t);
 }
 
-TEST(MSGPACK, stream_uint64)
+BOOST_AUTO_TEST_CASE(stream_uint64)
 {
     GEN_TEST_STREAM(uint64_t);
 }
 
-TEST(MSGPACK, stream_int8)
+BOOST_AUTO_TEST_CASE(stream_int8)
 {
     GEN_TEST_STREAM(int8_t);
 }
 
-TEST(MSGPACK, stream_int16)
+BOOST_AUTO_TEST_CASE(stream_int16)
 {
     GEN_TEST_STREAM(int16_t);
 }
 
-TEST(MSGPACK, stream_int32)
+BOOST_AUTO_TEST_CASE(stream_int32)
 {
     GEN_TEST_STREAM(int32_t);
 }
 
-TEST(MSGPACK, stream_int64)
+BOOST_AUTO_TEST_CASE(stream_int64)
 {
     GEN_TEST_STREAM(int64_t);
 }

test/msgpack_tuple.cpp

@@ -1,112 +1,106 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE msgpack_tuple
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+BOOST_AUTO_TEST_CASE(member_get)
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-TEST(msgpack_tuple, member_get)
 {
     msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
-    EXPECT_EQ(42, t1.get<0>());
+    BOOST_CHECK_EQUAL(42, t1.get<0>());
-    EXPECT_EQ(true, t1.get<1>());
+    BOOST_CHECK_EQUAL(true, t1.get<1>());
-    EXPECT_EQ("ABC", t1.get<2>());
+    BOOST_CHECK_EQUAL("ABC", t1.get<2>());
     t1.get<0>() = 40;
     t1.get<1>() = false;
     t1.get<2>() = "DEFG";
-    EXPECT_EQ(40, t1.get<0>());
+    BOOST_CHECK_EQUAL(40, t1.get<0>());
-    EXPECT_FALSE(t1.get<1>());
+    BOOST_CHECK(!t1.get<1>());
-    EXPECT_EQ("DEFG", t1.get<2>());
+    BOOST_CHECK_EQUAL("DEFG", t1.get<2>());
 }
 
-TEST(msgpack_tuple, non_member_get)
+BOOST_AUTO_TEST_CASE(non_member_get)
 {
     msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
-    EXPECT_EQ(42, msgpack::type::get<0>(t1));
+    BOOST_CHECK_EQUAL(42, msgpack::type::get<0>(t1));
-    EXPECT_EQ(true, msgpack::type::get<1>(t1));
+    BOOST_CHECK_EQUAL(true, msgpack::type::get<1>(t1));
-    EXPECT_EQ("ABC", msgpack::type::get<2>(t1));
+    BOOST_CHECK_EQUAL("ABC", msgpack::type::get<2>(t1));
     msgpack::type::get<0>(t1) = 40;
     msgpack::type::get<1>(t1) = false;
     msgpack::type::get<2>(t1) = "DEFG";
-    EXPECT_EQ(40, msgpack::type::get<0>(t1));
+    BOOST_CHECK_EQUAL(40, msgpack::type::get<0>(t1));
-    EXPECT_FALSE(msgpack::type::get<1>(t1));
+    BOOST_CHECK(!msgpack::type::get<1>(t1));
-    EXPECT_EQ("DEFG", msgpack::type::get<2>(t1));
+    BOOST_CHECK_EQUAL("DEFG", msgpack::type::get<2>(t1));
 }
 
-#if __cplusplus >= 201103L
+#if MSGPACK_CPP_VERSION >= 201103L
-TEST(msgpack_tuple, std_non_member_get)
+
+BOOST_AUTO_TEST_CASE(std_non_member_get)
 {
     msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
-    EXPECT_EQ(42, std::get<0>(t1));
+    BOOST_CHECK_EQUAL(42, std::get<0>(t1));
-    EXPECT_EQ(true, std::get<1>(t1));
+    BOOST_CHECK_EQUAL(true, std::get<1>(t1));
-    EXPECT_EQ("ABC", std::get<2>(t1));
+    BOOST_CHECK_EQUAL("ABC", std::get<2>(t1));
     std::get<0>(t1) = 40;
     std::get<1>(t1) = false;
     std::get<2>(t1) = "DEFG";
-    EXPECT_EQ(40, std::get<0>(t1));
+    BOOST_CHECK_EQUAL(40, std::get<0>(t1));
-    EXPECT_FALSE(std::get<1>(t1));
+    BOOST_CHECK(!std::get<1>(t1));
-    EXPECT_EQ("DEFG", std::get<2>(t1));
+    BOOST_CHECK_EQUAL("DEFG", std::get<2>(t1));
 }
 
-TEST(msgpack_tuple, make_tuple)
+BOOST_AUTO_TEST_CASE(make_tuple)
 {
     msgpack::type::tuple<int, bool, std::string> t1 = msgpack::type::make_tuple(42, true, "ABC");
-    EXPECT_EQ(42, t1.get<0>());
+    BOOST_CHECK_EQUAL(42, t1.get<0>());
-    EXPECT_EQ(true, t1.get<1>());
+    BOOST_CHECK_EQUAL(true, t1.get<1>());
-    EXPECT_EQ("ABC", t1.get<2>());
+    BOOST_CHECK_EQUAL("ABC", t1.get<2>());
     t1.get<0>() = 40;
     t1.get<1>() = false;
     t1.get<2>() = "DEFG";
-    EXPECT_EQ(40, t1.get<0>());
+    BOOST_CHECK_EQUAL(40, t1.get<0>());
-    EXPECT_FALSE(t1.get<1>());
+    BOOST_CHECK(!t1.get<1>());
-    EXPECT_EQ("DEFG", t1.get<2>());
+    BOOST_CHECK_EQUAL("DEFG", t1.get<2>());
 }
 
-TEST(msgpack_tuple, std_make_tuple)
+BOOST_AUTO_TEST_CASE(std_make_tuple)
 {
     msgpack::type::tuple<int, bool, std::string> t1 = std::make_tuple(42, true, "ABC");
-    EXPECT_EQ(42, t1.get<0>());
+    BOOST_CHECK_EQUAL(42, t1.get<0>());
-    EXPECT_EQ(true, t1.get<1>());
+    BOOST_CHECK_EQUAL(true, t1.get<1>());
-    EXPECT_EQ("ABC", t1.get<2>());
+    BOOST_CHECK_EQUAL("ABC", t1.get<2>());
 }
 
-TEST(msgpack_tuple, tie)
+BOOST_AUTO_TEST_CASE(tie)
 {
     int i(43);
     bool b(false);
     std::string s("DEFG");
     msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC");
-    EXPECT_EQ(42, i);
+    BOOST_CHECK_EQUAL(42, i);
-    EXPECT_EQ(true, b);
+    BOOST_CHECK_EQUAL(true, b);
-    EXPECT_EQ("ABC", s);
+    BOOST_CHECK_EQUAL("ABC", s);
 }
 
-TEST(msgpack_tuple, tuple_cat)
+BOOST_AUTO_TEST_CASE(tuple_cat)
 {
     msgpack::type::tuple<int> t1 = msgpack::type::make_tuple(42);
     msgpack::type::tuple<bool, std::string> t2 = msgpack::type::make_tuple(true, "ABC");
     msgpack::type::tuple<int, bool, std::string> t3 = msgpack::type::tuple_cat(t1, std::move(t2));
-    EXPECT_EQ(42, t3.get<0>());
+    BOOST_CHECK_EQUAL(42, t3.get<0>());
-    EXPECT_EQ(true, t3.get<1>());
+    BOOST_CHECK_EQUAL(true, t3.get<1>());
-    EXPECT_EQ("ABC", t3.get<2>());
+    BOOST_CHECK_EQUAL("ABC", t3.get<2>());
 }
 
-TEST(msgpack_tuple, swap)
+BOOST_AUTO_TEST_CASE(swap)
 {
     msgpack::type::tuple<int, bool, std::string>  t1 = msgpack::type::make_tuple(42, true, "ABC");
     msgpack::type::tuple<int, bool, std::string>  t2 = msgpack::type::make_tuple(40, false, "DEFG");
     msgpack::type::swap(t1, t2);
-    EXPECT_EQ(42, t2.get<0>());
+    BOOST_CHECK_EQUAL(42, t2.get<0>());
-    EXPECT_EQ(true, t2.get<1>());
+    BOOST_CHECK_EQUAL(true, t2.get<1>());
-    EXPECT_EQ("ABC", t2.get<2>());
+    BOOST_CHECK_EQUAL("ABC", t2.get<2>());
-    EXPECT_EQ(40, t1.get<0>());
+    BOOST_CHECK_EQUAL(40, t1.get<0>());
-    EXPECT_FALSE(t1.get<1>());
+    BOOST_CHECK(!t1.get<1>());
-    EXPECT_EQ("DEFG", t1.get<2>());
+    BOOST_CHECK_EQUAL("DEFG", t1.get<2>());
 }
-#endif
+
+#endif // MSGPACK_CPP_VERSION >= 201103L

test/msgpack_vref.cpp

@@ -9,16 +9,8 @@
 #include <list>
 #include <limits>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -41,246 +33,246 @@ using namespace std;
             msgpack::object_handle oh;                                  \
             msgpack::unpack(oh, sbuf.data(), sbuf.size());              \
             test_type val2 = oh.get().as<test_type>();                  \
-            EXPECT_EQ(val1, val2);                                      \
+            BOOST_CHECK_EQUAL(val1, val2);                              \
         }                                                               \
     } while(0);
 
-TEST(MSGPACK, vrefbuffer_char)
+BOOST_AUTO_TEST_CASE(vrefbuffer_char)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(char, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_signed_char)
+BOOST_AUTO_TEST_CASE(vrefbuffer_signed_char)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(signed char, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_unsigned_char)
+BOOST_AUTO_TEST_CASE(vrefbuffer_unsigned_char)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(unsigned char, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_short)
+BOOST_AUTO_TEST_CASE(vrefbuffer_short)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(short, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_int)
+BOOST_AUTO_TEST_CASE(vrefbuffer_int)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(int, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_long)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_long_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_long_long)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(long long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_unsigned_short)
+BOOST_AUTO_TEST_CASE(vrefbuffer_unsigned_short)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(unsigned short, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_unsigned_int)
+BOOST_AUTO_TEST_CASE(vrefbuffer_unsigned_int)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(unsigned int, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_unsigned_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_unsigned_long)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(unsigned long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_unsigned_long_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_unsigned_long_long)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(unsigned long long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_uint8)
+BOOST_AUTO_TEST_CASE(vrefbuffer_uint8)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(uint8_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_uint16)
+BOOST_AUTO_TEST_CASE(vrefbuffer_uint16)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(uint16_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_uint32)
+BOOST_AUTO_TEST_CASE(vrefbuffer_uint32)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(uint32_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_uint64)
+BOOST_AUTO_TEST_CASE(vrefbuffer_uint64)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(uint64_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_int8)
+BOOST_AUTO_TEST_CASE(vrefbuffer_int8)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(int8_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_int16)
+BOOST_AUTO_TEST_CASE(vrefbuffer_int16)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(int16_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_int32)
+BOOST_AUTO_TEST_CASE(vrefbuffer_int32)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(int32_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_int64)
+BOOST_AUTO_TEST_CASE(vrefbuffer_int64)
 {
     msgpack::vrefbuffer vbuf;
     GEN_TEST_VREF(int64_t, vbuf);
 }
 
 // small ref_size and chunk_size
-TEST(MSGPACK, vrefbuffer_small_char)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_char)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(char, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_signed_char)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_signed_char)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(signed char, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_unsigned_char)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_unsigned_char)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(unsigned char, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_short)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_short)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(short, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_int)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_int)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(int, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_long)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_long_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_long_long)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(long long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_unsigned_short)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_unsigned_short)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(unsigned short, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_unsigned_int)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_unsigned_int)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(unsigned int, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_unsigned_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_unsigned_long)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(unsigned long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_unsigned_long_long)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_unsigned_long_long)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(unsigned long long, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_uint8)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_uint8)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(uint8_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_uint16)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_uint16)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(uint16_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_uint32)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_uint32)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(uint32_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_uint64)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_uint64)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(uint64_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_int8)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_int8)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(int8_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_int16)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_int16)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(int16_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_int32)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_int32)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(int32_t, vbuf);
 }
 
-TEST(MSGPACK, vrefbuffer_small_int64)
+BOOST_AUTO_TEST_CASE(vrefbuffer_small_int64)
 {
     msgpack::vrefbuffer vbuf(0, 0);
     GEN_TEST_VREF(int64_t, vbuf);
 }
 
-TEST(MSGPACK, vref_buffer_overflow)
+BOOST_AUTO_TEST_CASE(vref_buffer_overflow)
 {
     size_t ref_size = 0;
     size_t chunk_size = std::numeric_limits<size_t>::max();
     char *buf = (char *)malloc(0x1000);
-    ASSERT_THROW(msgpack::vrefbuffer vbuf(ref_size, chunk_size), std::bad_alloc);
+    BOOST_CHECK_THROW(msgpack::vrefbuffer vbuf(ref_size, chunk_size), std::bad_alloc);
     msgpack::vrefbuffer vbuf2(0, 0x1000);
-    ASSERT_THROW(vbuf2.append_copy(buf, chunk_size), std::bad_alloc);
+    BOOST_CHECK_THROW(vbuf2.append_copy(buf, chunk_size), std::bad_alloc);
     free(buf);
 }

test/msgpack_x3_parse.cpp

@@ -4,19 +4,11 @@
 #include <limits>
 #include <cmath>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_X3_PARSE
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 // To avoid link error
-TEST(MSGPACK_X3_PARSE, dummy)
+BOOST_AUTO_TEST_CASE(dummy)
 {
 }
 
@@ -26,247 +18,247 @@ using namespace std;
 
 const double kEPS = 1e-10;
 
-TEST(MSGPACK_X3_PARSE, nil_t)
+BOOST_AUTO_TEST_CASE(nil_t)
 {
     msgpack::type::nil_t v;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_TRUE(oh.get().is_nil());
+    BOOST_CHECK(oh.get().is_nil());
 }
 
-TEST(MSGPACK_X3_PARSE, bool_false)
+BOOST_AUTO_TEST_CASE(bool_false)
 {
     bool v = false;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<bool>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<bool>());
 }
 
-TEST(MSGPACK_X3_PARSE, bool_true)
+BOOST_AUTO_TEST_CASE(bool_true)
 {
     bool v = true;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<bool>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<bool>());
 }
 
-TEST(MSGPACK_X3_PARSE, positive_fixint_1)
+BOOST_AUTO_TEST_CASE(positive_fixint_1)
 {
     uint8_t v = 0;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, positive_fixint_2)
+BOOST_AUTO_TEST_CASE(positive_fixint_2)
 {
     uint8_t v = 127;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, negative_fixint_1)
+BOOST_AUTO_TEST_CASE(negative_fixint_1)
 {
     int8_t v = -1;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, negative_fixint_2)
+BOOST_AUTO_TEST_CASE(negative_fixint_2)
 {
     int8_t v = -32;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint8_1)
+BOOST_AUTO_TEST_CASE(uint8_1)
 {
     uint8_t v = 128U;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint8_2)
+BOOST_AUTO_TEST_CASE(uint8_2)
 {
     uint8_t v = 0xffU;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint16_1)
+BOOST_AUTO_TEST_CASE(uint16_1)
 {
     uint16_t v = 0x100U;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint16_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint16_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint16_2)
+BOOST_AUTO_TEST_CASE(uint16_2)
 {
     uint16_t v = 0xffffU;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint16_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint16_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint32_1)
+BOOST_AUTO_TEST_CASE(uint32_1)
 {
     uint32_t v = 0x10000UL;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint32_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint32_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint32_2)
+BOOST_AUTO_TEST_CASE(uint32_2)
 {
     uint32_t v = 0xffffffffUL;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint32_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint32_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint64_1)
+BOOST_AUTO_TEST_CASE(uint64_1)
 {
     uint64_t v = 0x100000000ULL;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint64_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint64_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, uint64_2)
+BOOST_AUTO_TEST_CASE(uint64_2)
 {
     uint64_t v = 0xffffffffffffffffULL;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<uint64_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<uint64_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int8_1)
+BOOST_AUTO_TEST_CASE(int8_1)
 {
     int8_t v = static_cast<int8_t>(0b11011111);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int8_2)
+BOOST_AUTO_TEST_CASE(int8_2)
 {
     int8_t v = static_cast<int8_t>(0b10000000);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int8_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int16_1)
+BOOST_AUTO_TEST_CASE(int16_1)
 {
     int16_t v = static_cast<int16_t>(0xff00);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int16_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int16_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int16_2)
+BOOST_AUTO_TEST_CASE(int16_2)
 {
     int16_t v = static_cast<int16_t>(0x8000);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int16_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int16_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int32_1)
+BOOST_AUTO_TEST_CASE(int32_1)
 {
     int32_t v = static_cast<int32_t>(0xff000000L);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int32_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int32_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int32_2)
+BOOST_AUTO_TEST_CASE(int32_2)
 {
     int32_t v = static_cast<int32_t>(0x80000000L);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int32_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int32_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int64_1)
+BOOST_AUTO_TEST_CASE(int64_1)
 {
     int64_t v = static_cast<int64_t>(0xff00000000000000LL);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int64_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int64_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, int64_2)
+BOOST_AUTO_TEST_CASE(int64_2)
 {
     int64_t v = static_cast<int64_t>(0x8000000000000000LL);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<int64_t>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<int64_t>());
 }
 
-TEST(MSGPACK_X3_PARSE, array_1)
+BOOST_AUTO_TEST_CASE(array_1)
 {
     std::vector<int> v;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+    BOOST_CHECK(v == oh.get().as<std::vector<int> >());
 }
 
-TEST(MSGPACK_X3_PARSE, array_2)
+BOOST_AUTO_TEST_CASE(array_2)
 {
     std::vector<int> v;
     std::stringstream ss;
@@ -274,10 +266,10 @@ TEST(MSGPACK_X3_PARSE, array_2)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+    BOOST_CHECK(v == oh.get().as<std::vector<int> >());
 }
 
-TEST(MSGPACK_X3_PARSE, array_3)
+BOOST_AUTO_TEST_CASE(array_3)
 {
     std::vector<int> v;
     std::stringstream ss;
@@ -285,10 +277,10 @@ TEST(MSGPACK_X3_PARSE, array_3)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+    BOOST_CHECK(v == oh.get().as<std::vector<int> >());
 }
 
-TEST(MSGPACK_X3_PARSE, array_4)
+BOOST_AUTO_TEST_CASE(array_4)
 {
     std::vector<int> v;
     std::stringstream ss;
@@ -296,10 +288,10 @@ TEST(MSGPACK_X3_PARSE, array_4)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+    BOOST_CHECK(v == oh.get().as<std::vector<int> >());
 }
 
-TEST(MSGPACK_X3_PARSE, array_5)
+BOOST_AUTO_TEST_CASE(array_5)
 {
     std::vector<uint32_t> v;
     std::stringstream ss;
@@ -307,20 +299,20 @@ TEST(MSGPACK_X3_PARSE, array_5)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<uint32_t> >());
+    BOOST_CHECK(v == oh.get().as<std::vector<uint32_t> >());
 }
 
-TEST(MSGPACK_X3_PARSE, map_1)
+BOOST_AUTO_TEST_CASE(map_1)
 {
     std::map<int, int> v;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+    BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
 }
 
-TEST(MSGPACK_X3_PARSE, map_2)
+BOOST_AUTO_TEST_CASE(map_2)
 {
     std::map<int, int> v;
     std::stringstream ss;
@@ -328,10 +320,10 @@ TEST(MSGPACK_X3_PARSE, map_2)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+    BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
 }
 
-TEST(MSGPACK_X3_PARSE, map_3)
+BOOST_AUTO_TEST_CASE(map_3)
 {
     std::map<int, int> v;
     std::stringstream ss;
@@ -339,10 +331,10 @@ TEST(MSGPACK_X3_PARSE, map_3)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+    BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
 }
 
-TEST(MSGPACK_X3_PARSE, map_4)
+BOOST_AUTO_TEST_CASE(map_4)
 {
     std::map<int, int> v;
     std::stringstream ss;
@@ -350,10 +342,10 @@ TEST(MSGPACK_X3_PARSE, map_4)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+    BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
 }
 
-TEST(MSGPACK_X3_PARSE, map_5)
+BOOST_AUTO_TEST_CASE(map_5)
 {
     std::map<uint32_t, uint32_t> v;
     std::stringstream ss;
@@ -361,10 +353,10 @@ TEST(MSGPACK_X3_PARSE, map_5)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, (oh.get().as<std::map<uint32_t, uint32_t> >()));
+    BOOST_CHECK(v == (oh.get().as<std::map<uint32_t, uint32_t> >()));
 }
 
-TEST(MSGPACK_X3_PARSE, float_1)
+BOOST_AUTO_TEST_CASE(float_1)
 {
     std::vector<float> v;
     v.push_back(0.0);
@@ -394,15 +386,15 @@ TEST(MSGPACK_X3_PARSE, float_1)
         float val2 = oh.get().as<float>();
 
         if (std::isnan(val1))
-            EXPECT_TRUE(std::isnan(val2));
+            BOOST_CHECK(std::isnan(val2));
         else if (std::isinf(val1))
-            EXPECT_TRUE(std::isinf(val2));
+            BOOST_CHECK(std::isinf(val2));
         else
-            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+            BOOST_CHECK(fabs(val2 - val1) <= kEPS);
     }
 }
 
-TEST(MSGPACK_X3_PARSE, double_1)
+BOOST_AUTO_TEST_CASE(double_1)
 {
     std::vector<double> v;
     v.push_back(0.0);
@@ -432,25 +424,25 @@ TEST(MSGPACK_X3_PARSE, double_1)
         double val2 = oh.get().as<double>();
 
         if (std::isnan(val1))
-            EXPECT_TRUE(std::isnan(val2));
+            BOOST_CHECK(std::isnan(val2));
         else if (std::isinf(val1))
-            EXPECT_TRUE(std::isinf(val2));
+            BOOST_CHECK(std::isinf(val2));
         else
-            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+            BOOST_CHECK(fabs(val2 - val1) <= kEPS);
     }
 }
 
-TEST(MSGPACK_X3_PARSE, string_1)
+BOOST_AUTO_TEST_CASE(string_1)
 {
     std::string v;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, string_2)
+BOOST_AUTO_TEST_CASE(string_2)
 {
     std::string v;
 
@@ -460,10 +452,10 @@ TEST(MSGPACK_X3_PARSE, string_2)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, string_3)
+BOOST_AUTO_TEST_CASE(string_3)
 {
     std::string v;
 
@@ -473,10 +465,10 @@ TEST(MSGPACK_X3_PARSE, string_3)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, string_4)
+BOOST_AUTO_TEST_CASE(string_4)
 {
     std::string v;
 
@@ -486,10 +478,10 @@ TEST(MSGPACK_X3_PARSE, string_4)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, string_5)
+BOOST_AUTO_TEST_CASE(string_5)
 {
     std::string v;
 
@@ -499,10 +491,10 @@ TEST(MSGPACK_X3_PARSE, string_5)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, string_6)
+BOOST_AUTO_TEST_CASE(string_6)
 {
     std::string v;
 
@@ -512,20 +504,20 @@ TEST(MSGPACK_X3_PARSE, string_6)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, bin_1)
+BOOST_AUTO_TEST_CASE(bin_1)
 {
     std::vector<char> v;
     std::stringstream ss;
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+    BOOST_CHECK(v == oh.get().as<std::vector<char>>());
 }
 
-TEST(MSGPACK_X3_PARSE, bin_2)
+BOOST_AUTO_TEST_CASE(bin_2)
 {
     std::vector<char> v;
 
@@ -535,10 +527,10 @@ TEST(MSGPACK_X3_PARSE, bin_2)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+    BOOST_CHECK(v == oh.get().as<std::vector<char>>());
 }
 
-TEST(MSGPACK_X3_PARSE, bin_3)
+BOOST_AUTO_TEST_CASE(bin_3)
 {
     std::vector<char> v;
 
@@ -548,10 +540,10 @@ TEST(MSGPACK_X3_PARSE, bin_3)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+    BOOST_CHECK(v == oh.get().as<std::vector<char>>());
 }
 
-TEST(MSGPACK_X3_PARSE, bin_4)
+BOOST_AUTO_TEST_CASE(bin_4)
 {
     std::vector<char> v;
 
@@ -561,10 +553,10 @@ TEST(MSGPACK_X3_PARSE, bin_4)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+    BOOST_CHECK(v == oh.get().as<std::vector<char>>());
 }
 
-TEST(MSGPACK_X3_PARSE, bin_5)
+BOOST_AUTO_TEST_CASE(bin_5)
 {
     std::vector<char> v;
 
@@ -574,10 +566,10 @@ TEST(MSGPACK_X3_PARSE, bin_5)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+    BOOST_CHECK(v == oh.get().as<std::vector<char>>());
 }
 
-TEST(MSGPACK_X3_PARSE, bin_6)
+BOOST_AUTO_TEST_CASE(bin_6)
 {
     std::vector<char> v;
 
@@ -587,10 +579,10 @@ TEST(MSGPACK_X3_PARSE, bin_6)
     msgpack::pack(ss, v);
 
     auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+    BOOST_CHECK(v == oh.get().as<std::vector<char>>());
 }
 
-TEST(MSGPACK_X3_PARSE, fixext1)
+BOOST_AUTO_TEST_CASE(fixext1)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -600,12 +592,12 @@ TEST(MSGPACK_X3_PARSE, fixext1)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(1ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(1ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_EQ(2, oh.get().via.ext.data()[0]);
+    BOOST_CHECK_EQUAL(2, oh.get().via.ext.data()[0]);
 }
 
-TEST(MSGPACK_X3_PARSE, fixext2)
+BOOST_AUTO_TEST_CASE(fixext2)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -615,13 +607,13 @@ TEST(MSGPACK_X3_PARSE, fixext2)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(2ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(2ul, oh.get().via.ext.size);
-    EXPECT_EQ(0, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(0, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, fixext4)
+BOOST_AUTO_TEST_CASE(fixext4)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -631,13 +623,13 @@ TEST(MSGPACK_X3_PARSE, fixext4)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(4ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(4ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, fixext8)
+BOOST_AUTO_TEST_CASE(fixext8)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -647,13 +639,13 @@ TEST(MSGPACK_X3_PARSE, fixext8)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(8ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(8ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, fixext16)
+BOOST_AUTO_TEST_CASE(fixext16)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> packer(ss);
@@ -663,13 +655,13 @@ TEST(MSGPACK_X3_PARSE, fixext16)
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(16ul, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(16ul, oh.get().via.ext.size);
-    EXPECT_EQ(1, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, ext_0)
+BOOST_AUTO_TEST_CASE(ext_0)
 {
     std::size_t const size = 0;
     std::stringstream ss;
@@ -678,11 +670,11 @@ TEST(MSGPACK_X3_PARSE, ext_0)
     packer.pack_ext(size, 77);
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
 }
 
-TEST(MSGPACK_X3_PARSE, ext_255)
+BOOST_AUTO_TEST_CASE(ext_255)
 {
     std::size_t const size = 255;
     std::stringstream ss;
@@ -694,13 +686,13 @@ TEST(MSGPACK_X3_PARSE, ext_255)
 
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, ext_256)
+BOOST_AUTO_TEST_CASE(ext_256)
 {
     std::size_t const size = 256;
     std::stringstream ss;
@@ -712,13 +704,13 @@ TEST(MSGPACK_X3_PARSE, ext_256)
 
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, ext_65535)
+BOOST_AUTO_TEST_CASE(ext_65535)
 {
     std::size_t const size = 65535;
     std::stringstream ss;
@@ -730,13 +722,13 @@ TEST(MSGPACK_X3_PARSE, ext_65535)
 
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, ext_65536)
+BOOST_AUTO_TEST_CASE(ext_65536)
 {
     std::size_t const size = 65536;
     std::stringstream ss;
@@ -748,13 +740,13 @@ TEST(MSGPACK_X3_PARSE, ext_65536)
 
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end());
-    EXPECT_EQ(size, oh.get().via.ext.size);
+    BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
-    EXPECT_EQ(77, oh.get().via.ext.type());
+    BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
-    EXPECT_TRUE(
+    BOOST_CHECK(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
 }
 
-TEST(MSGPACK_X3_PARSE, unpack_referenced_1)
+BOOST_AUTO_TEST_CASE(unpack_referenced_1)
 {
     std::string v = "ABC";
     std::stringstream ss;
@@ -763,11 +755,11 @@ TEST(MSGPACK_X3_PARSE, unpack_referenced_1)
     bool r;
     msgpack::object_handle oh =
         msgpack::unpack(ss.str().begin(), ss.str().end(), r);
-    EXPECT_FALSE(r);
+    BOOST_CHECK(!r);
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, unpack_referenced_2)
+BOOST_AUTO_TEST_CASE(unpack_referenced_2)
 {
     std::string v = "ABC";
     std::stringstream ss;
@@ -785,11 +777,11 @@ TEST(MSGPACK_X3_PARSE, unpack_referenced_2)
                 return true;
             }
         );
-    EXPECT_TRUE(r);
+    BOOST_CHECK(r);
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, unpack_zone_1)
+BOOST_AUTO_TEST_CASE(unpack_zone_1)
 {
     std::string v = "ABC";
     std::stringstream ss;
@@ -798,10 +790,10 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_1)
     msgpack::zone z;
     msgpack::object obj =
         msgpack::unpack(z, ss.str().begin(), ss.str().end());
-    EXPECT_EQ(v, obj.as<std::string>());
+    BOOST_CHECK_EQUAL(v, obj.as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, unpack_zone_2)
+BOOST_AUTO_TEST_CASE(unpack_zone_2)
 {
     std::string v = "ABC";
     std::stringstream ss;
@@ -811,13 +803,13 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_2)
     bool r;
     msgpack::object obj =
         msgpack::unpack(z, ss.str().begin(), ss.str().end(), r);
-    EXPECT_EQ(v, obj.as<std::string>());
+    BOOST_CHECK_EQUAL(v, obj.as<std::string>());
 
-    EXPECT_FALSE(r);
+    BOOST_CHECK(!r);
-    EXPECT_EQ(v, obj.as<std::string>());
+    BOOST_CHECK_EQUAL(v, obj.as<std::string>());
 }
 
-TEST(MSGPACK_X3_PARSE, unpack_zone_3)
+BOOST_AUTO_TEST_CASE(unpack_zone_3)
 {
     std::string v = "ABC";
     std::stringstream ss;
@@ -837,8 +829,8 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_3)
                 return true;
             }
         );
-    EXPECT_TRUE(r);
+    BOOST_CHECK(r);
-    EXPECT_EQ(v, obj.as<std::string>());
+    BOOST_CHECK_EQUAL(v, obj.as<std::string>());
 }
 
 #endif // defined(MSGPACK_USE_X3_PARSE) && MSGPACK_DEFAULT_API_VERSION >= 2

test/object.cpp

@@ -1,15 +1,7 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE object
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 enum enum_test {
     elem
@@ -70,7 +62,7 @@ std::ostream& operator<<(std::ostream& o, const myclass& m)
 }
 
 
-TEST(object, convert)
+BOOST_AUTO_TEST_CASE(convert)
 {
     myclass m1(1, "custom");
 
@@ -83,11 +75,11 @@ TEST(object, convert)
     myclass m2;
     oh.get().convert(m2);
 
-    EXPECT_EQ(m1, m2);
+    BOOST_CHECK_EQUAL(m1, m2);
 }
 
 
-TEST(object, as)
+BOOST_AUTO_TEST_CASE(as)
 {
     myclass m1(1, "custom");
 
@@ -97,10 +89,10 @@ TEST(object, as)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
 
-    EXPECT_EQ(m1, oh.get().as<myclass>());
+    BOOST_CHECK_EQUAL(m1, oh.get().as<myclass>());
 }
 
-TEST(object, cross_zone_copy)
+BOOST_AUTO_TEST_CASE(cross_zone_copy)
 {
     myclass m1(1, "custom");
     m1.vec.push_back(1.0);
@@ -121,30 +113,30 @@ TEST(object, cross_zone_copy)
 
         obj1 << obj2;
 
-        EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.f64, 1.0);
+        BOOST_CHECK_EQUAL(obj1.via.array.ptr[2].via.array.ptr[0].via.f64, 1.0);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-        EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0);
+        BOOST_CHECK_EQUAL(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0);
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
-        EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr[0], 'o');
+        BOOST_CHECK_EQUAL(obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr[0], 'o');
-        EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
+        BOOST_CHECK_EQUAL(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
-        EXPECT_NE(
+        BOOST_CHECK_NE(
             obj1.via.array.ptr[2].via.array.ptr,
             obj2.via.array.ptr[2].via.array.ptr);
-        EXPECT_NE(
+        BOOST_CHECK_NE(
             obj1.via.array.ptr[3].via.map.ptr,
             obj2.via.array.ptr[3].via.map.ptr);
-        EXPECT_NE(
+        BOOST_CHECK(
-            obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr,
+            obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr !=
             obj2.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr);
-        EXPECT_NE(
+        BOOST_CHECK(
-            obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr,
+            obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr !=
             obj2.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr);
     }
 
-    EXPECT_EQ(m1, obj1.as<myclass>());
+    BOOST_CHECK_EQUAL(m1, obj1.as<myclass>());
 }
 
-TEST(object, cross_zone_copy_construct)
+BOOST_AUTO_TEST_CASE(cross_zone_copy_construct)
 {
     myclass m1(1, "custom");
     m1.vec.push_back(1.0);
@@ -162,28 +154,28 @@ TEST(object, cross_zone_copy_construct)
 
     msgpack::object obj1(obj2, z1);
 
-    EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.f64, 1.0);
+    BOOST_CHECK_EQUAL(obj1.via.array.ptr[2].via.array.ptr[0].via.f64, 1.0);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-    EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0);
+    BOOST_CHECK_EQUAL(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0);
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
-    EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr[0], 'o');
+    BOOST_CHECK_EQUAL(obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr[0], 'o');
-    EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
+    BOOST_CHECK_EQUAL(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
-    EXPECT_NE(
+    BOOST_CHECK_NE(
         obj1.via.array.ptr[2].via.array.ptr,
         obj2.via.array.ptr[2].via.array.ptr);
-    EXPECT_NE(
+    BOOST_CHECK_NE(
         obj1.via.array.ptr[3].via.map.ptr,
         obj2.via.array.ptr[3].via.map.ptr);
-    EXPECT_NE(
+    BOOST_CHECK(
-        obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr,
+        obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr !=
         obj2.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr);
-    EXPECT_NE(
+    BOOST_CHECK(
-        obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr,
+        obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr !=
         obj2.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr);
-    EXPECT_EQ(m1, obj1.as<myclass>());
+    BOOST_CHECK_EQUAL(m1, obj1.as<myclass>());
 }
 
-TEST(object, cross_zone_copy_ext)
+BOOST_AUTO_TEST_CASE(cross_zone_copy_ext)
 {
     msgpack::zone z1;
     msgpack::zone z2;
@@ -198,15 +190,15 @@ TEST(object, cross_zone_copy_ext)
 
     msgpack::object::with_zone obj2(z2);
     obj2 << obj1;
-    EXPECT_EQ(obj2.via.ext.size, 1u);
+    BOOST_CHECK_EQUAL(obj2.via.ext.size, 1u);
-    EXPECT_EQ(obj2.via.ext.ptr[0], 1);
+    BOOST_CHECK_EQUAL(obj2.via.ext.ptr[0], 1);
-    EXPECT_EQ(obj2.via.ext.ptr[1], 2);
+    BOOST_CHECK_EQUAL(obj2.via.ext.ptr[1], 2);
-    EXPECT_NE(
+    BOOST_CHECK(
-        obj1.via.ext.ptr,
+        obj1.via.ext.ptr !=
         obj2.via.ext.ptr);
 }
 
-TEST(object, cross_zone_copy_construct_ext)
+BOOST_AUTO_TEST_CASE(cross_zone_copy_construct_ext)
 {
     msgpack::zone z1;
     msgpack::zone z2;
@@ -220,155 +212,153 @@ TEST(object, cross_zone_copy_construct_ext)
     obj1.via.ext.size = 1;
 
     msgpack::object obj2(obj1, z2);
-    EXPECT_EQ(obj2.via.ext.size, 1u);
+    BOOST_CHECK_EQUAL(obj2.via.ext.size, 1u);
-    EXPECT_EQ(obj2.via.ext.ptr[0], 1);
+    BOOST_CHECK_EQUAL(obj2.via.ext.ptr[0], 1);
-    EXPECT_EQ(obj2.via.ext.ptr[1], 2);
+    BOOST_CHECK_EQUAL(obj2.via.ext.ptr[1], 2);
-    EXPECT_NE(
+    BOOST_CHECK(
-        obj1.via.ext.ptr,
+        obj1.via.ext.ptr !=
         obj2.via.ext.ptr);
 }
 
-TEST(object, print)
+BOOST_AUTO_TEST_CASE(print)
 {
     msgpack::object obj;
-    std::cout << obj << std::endl;
+    std::stringstream output;
+    output << obj;
+    BOOST_CHECK_EQUAL(output.str(), "null");
 }
 
-
+BOOST_AUTO_TEST_CASE(is_nil)
-TEST(object, is_nil)
 {
     msgpack::object obj;
-    EXPECT_TRUE(obj.is_nil());
+    BOOST_CHECK(obj.is_nil());
 }
 
-
+BOOST_AUTO_TEST_CASE(type_error)
-TEST(object, type_error)
 {
     msgpack::object obj(1);
-    EXPECT_THROW(obj.as<std::string>(), msgpack::type_error);
+    BOOST_CHECK_THROW(obj.as<std::string>(), msgpack::type_error);
-    EXPECT_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
+    BOOST_CHECK_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
-    EXPECT_EQ(1, obj.as<int>());
+    BOOST_CHECK_EQUAL(1, obj.as<int>());
-    EXPECT_EQ(1, obj.as<short>());
+    BOOST_CHECK_EQUAL(1, obj.as<short>());
-    EXPECT_EQ(1u, obj.as<unsigned int>());
+    BOOST_CHECK_EQUAL(1u, obj.as<unsigned int>());
-    EXPECT_EQ(1u, obj.as<unsigned long>());
+    BOOST_CHECK_EQUAL(1u, obj.as<unsigned long>());
 }
 
-
+BOOST_AUTO_TEST_CASE(equal_primitive)
-TEST(object, equal_primitive)
 {
     msgpack::object obj_nil;
-    EXPECT_EQ(obj_nil, msgpack::object());
+    BOOST_CHECK_EQUAL(obj_nil, msgpack::object());
 
     msgpack::object obj_int(1);
-    EXPECT_EQ(obj_int, msgpack::object(1));
+    BOOST_CHECK_EQUAL(obj_int, msgpack::object(1));
-    EXPECT_EQ(obj_int, 1);
+    BOOST_CHECK_EQUAL(obj_int, 1);
 
     msgpack::object obj_float(1.2);
-    EXPECT_EQ(obj_float, msgpack::object(1.2));
+    BOOST_CHECK_EQUAL(obj_float, msgpack::object(1.2));
-    EXPECT_EQ(obj_float, 1.2);
+    BOOST_CHECK_EQUAL(obj_float, 1.2);
 
     msgpack::object obj_bool(true);
-    EXPECT_EQ(obj_bool, msgpack::object(true));
+    BOOST_CHECK_EQUAL(obj_bool, msgpack::object(true));
-    EXPECT_EQ(obj_bool, true);
+    BOOST_CHECK_EQUAL(obj_bool, true);
 }
 
-
+BOOST_AUTO_TEST_CASE(construct_primitive)
-TEST(object, construct_primitive)
 {
     msgpack::object obj_nil;
-    EXPECT_EQ(msgpack::type::NIL, obj_nil.type);
+    BOOST_CHECK_EQUAL(msgpack::type::NIL, obj_nil.type);
 
     msgpack::object obj_uint(1);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj_uint.type);
-    EXPECT_EQ(1u, obj_uint.via.u64);
+    BOOST_CHECK_EQUAL(1u, obj_uint.via.u64);
 
     msgpack::object obj_int(-1);
-    EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
+    BOOST_CHECK_EQUAL(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
-    EXPECT_EQ(-1, obj_int.via.i64);
+    BOOST_CHECK_EQUAL(-1, obj_int.via.i64);
 
     msgpack::object obj_float(1.2F);
-    EXPECT_EQ(msgpack::type::FLOAT32, obj_float.type);
+    BOOST_CHECK_EQUAL(msgpack::type::FLOAT32, obj_float.type);
-    EXPECT_EQ(1.2F, obj_float.via.f64);
+    BOOST_CHECK_EQUAL(1.2F, obj_float.via.f64);
 
     msgpack::object obj_double(1.2);
-    EXPECT_EQ(msgpack::type::FLOAT64, obj_double.type);
+    BOOST_CHECK_EQUAL(msgpack::type::FLOAT64, obj_double.type);
-    EXPECT_EQ(msgpack::type::FLOAT, obj_double.type);
+    BOOST_CHECK_EQUAL(msgpack::type::FLOAT, obj_double.type);
-    EXPECT_EQ(1.2, obj_double.via.f64);
+    BOOST_CHECK_EQUAL(1.2, obj_double.via.f64);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-    EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type);
+    BOOST_CHECK_EQUAL(msgpack::type::DOUBLE, obj_double.type);
-    EXPECT_EQ(1.2, obj_double.via.dec);
+    BOOST_CHECK_EQUAL(1.2, obj_double.via.dec);
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
 
     msgpack::object obj_bool(true);
-    EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type);
+    BOOST_CHECK_EQUAL(msgpack::type::BOOLEAN, obj_bool.type);
-    EXPECT_EQ(true, obj_bool.via.boolean);
+    BOOST_CHECK_EQUAL(true, obj_bool.via.boolean);
 }
 
-TEST(object, construct_enum)
+BOOST_AUTO_TEST_CASE(construct_enum)
 {
     msgpack::object obj(elem);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
-    EXPECT_EQ(static_cast<uint64_t>(elem), obj.via.u64);
+    BOOST_CHECK_EQUAL(static_cast<uint64_t>(elem), obj.via.u64);
 }
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(object, construct_enum_newstyle)
+BOOST_AUTO_TEST_CASE(construct_enum_newstyle)
 {
     msgpack::object obj(enum_test::elem);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
-    EXPECT_EQ(elem, obj.via.u64);
+    BOOST_CHECK_EQUAL(elem, obj.via.u64);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)
 
-TEST(object, construct_enum_outer)
+BOOST_AUTO_TEST_CASE(construct_enum_outer)
 {
     msgpack::object obj(outer_enum::elem);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
-    EXPECT_EQ(static_cast<uint64_t>(elem), obj.via.u64);
+    BOOST_CHECK_EQUAL(static_cast<uint64_t>(elem), obj.via.u64);
 }
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(object, construct_enum_outer_newstyle)
+BOOST_AUTO_TEST_CASE(construct_enum_outer_newstyle)
 {
     msgpack::object obj(outer_enum::enum_test::elem);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
-    EXPECT_EQ(elem, obj.via.u64);
+    BOOST_CHECK_EQUAL(elem, obj.via.u64);
 }
 
-TEST(object, construct_class_enum)
+BOOST_AUTO_TEST_CASE(construct_class_enum)
 {
     msgpack::object obj(enum_class_test::elem);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
-    EXPECT_EQ(elem, obj.via.u64);
+    BOOST_CHECK_EQUAL(elem, obj.via.u64);
 }
 
 
-TEST(object, construct_class_enum_outer)
+BOOST_AUTO_TEST_CASE(construct_class_enum_outer)
 {
     msgpack::object obj(outer_enum_class::enum_class_test::elem);
-    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
+    BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
-    EXPECT_EQ(elem, obj.via.u64);
+    BOOST_CHECK_EQUAL(elem, obj.via.u64);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)
 
-TEST(object, clone_int)
+BOOST_AUTO_TEST_CASE(clone_int)
 {
     int v = 0;
     msgpack::object obj(v);
     std::size_t sz1 = msgpack::aligned_zone_size(obj);
     msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
+    BOOST_CHECK_EQUAL(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
     h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
+    BOOST_CHECK_EQUAL(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
 }
 
-TEST(object, clone_str)
+BOOST_AUTO_TEST_CASE(clone_str)
 {
     msgpack::object_handle oh;
     std::string v = "123456789";
@@ -377,17 +367,17 @@ TEST(object, clone_str)
         msgpack::object obj(v, z);
         std::size_t sz1 = msgpack::aligned_zone_size(obj);
         msgpack::object_handle h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         oh = msgpack::move(h);
     }
-    EXPECT_EQ(v, oh.get().as<std::string>());
+    BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
 }
 
-TEST(object, clone_bin)
+BOOST_AUTO_TEST_CASE(clone_bin)
 {
     msgpack::object_handle oh;
     std::vector<char> v;
@@ -399,19 +389,19 @@ TEST(object, clone_bin)
         msgpack::object obj(v, z);
         std::size_t sz1 = msgpack::aligned_zone_size(obj);
         msgpack::object_handle h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         oh = msgpack::move(h);
     }
     std::vector<char> v2 = oh.get().as<std::vector<char> >();
-    EXPECT_EQ(v.size(), v2.size());
+    BOOST_CHECK_EQUAL(v.size(), v2.size());
-    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
+    BOOST_CHECK(equal(v.begin(), v.end(), v2.begin()));
 }
 
-TEST(object, clone_array)
+BOOST_AUTO_TEST_CASE(clone_array)
 {
     msgpack::object_handle oh;
     std::vector<int> v;
@@ -423,19 +413,19 @@ TEST(object, clone_array)
         msgpack::object obj(v, z);
         std::size_t sz1 = msgpack::aligned_zone_size(obj);
         msgpack::object_handle h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         oh = msgpack::move(h);
     }
     std::vector<int> v2 = oh.get().as<std::vector<int> >();
-    EXPECT_EQ(v.size(), v2.size());
+    BOOST_CHECK_EQUAL(v.size(), v2.size());
-    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
+    BOOST_CHECK(equal(v.begin(), v.end(), v2.begin()));
 }
 
-TEST(object, clone_map)
+BOOST_AUTO_TEST_CASE(clone_map)
 {
     msgpack::object_handle oh;
     std::map<int, std::string> v;
@@ -447,45 +437,128 @@ TEST(object, clone_map)
         msgpack::object obj(v, z);
         std::size_t sz1 = msgpack::aligned_zone_size(obj);
         msgpack::object_handle h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         h = msgpack::clone(obj);
-        EXPECT_EQ(h.get(), obj);
+        BOOST_CHECK_EQUAL(h.get(), obj);
-        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
         oh = msgpack::move(h);
     }
     std::map<int, std::string> v2 = oh.get().as<std::map<int, std::string> >();
-    EXPECT_EQ(v.size(), v2.size());
+    BOOST_CHECK_EQUAL(v.size(), v2.size());
-    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
+    BOOST_CHECK(equal(v.begin(), v.end(), v2.begin()));
 }
 
-TEST(object, pack_float)
+BOOST_AUTO_TEST_CASE(pack_float)
 {
     msgpack::object obj(1.2F);
     std::stringstream ss1;
     msgpack::pack(ss1, obj);
     std::stringstream ss2;
     msgpack::pack(ss2, 1.2F);
-    EXPECT_EQ(static_cast<size_t>(5), ss1.str().size());
+    BOOST_CHECK_EQUAL(static_cast<size_t>(5), ss1.str().size());
-    EXPECT_EQ(ss1.str(), ss2.str());
+    BOOST_CHECK_EQUAL(ss1.str(), ss2.str());
 }
 
-TEST(object, pack_double)
+BOOST_AUTO_TEST_CASE(pack_double)
 {
     msgpack::object obj(1.2);
     std::stringstream ss1;
     msgpack::pack(ss1, obj);
     std::stringstream ss2;
     msgpack::pack(ss2, 1.2);
-    EXPECT_EQ(static_cast<size_t>(9), ss1.str().size());
+    BOOST_CHECK_EQUAL(static_cast<size_t>(9), ss1.str().size());
-    EXPECT_EQ(ss1.str(), ss2.str());
+    BOOST_CHECK_EQUAL(ss1.str(), ss2.str());
 }
 
-TEST(object, handle_operators)
+BOOST_AUTO_TEST_CASE(handle_operators)
 {
     int i = 1;
     msgpack::object obj(i);
     msgpack::object_handle oh = msgpack::clone(obj);
-    EXPECT_EQ(oh.get(), *oh);
+    BOOST_CHECK_EQUAL(oh.get(), *oh);
-    EXPECT_EQ(oh->as<int>(), oh.get().as<int>());
+    BOOST_CHECK_EQUAL(oh->as<int>(), oh.get().as<int>());
 }
+
+const unsigned int kLoop = 1000;
+const unsigned int kElements = 100;
+
+BOOST_AUTO_TEST_CASE(vector_char)
+{
+    for (unsigned int k = 0; k < kLoop; k++) {
+        std::vector<char> v1;
+        v1.push_back(1);
+        for (unsigned int i = 1; i < kElements; i++)
+            v1.push_back(static_cast<char>(i));
+        msgpack::object obj(v1);
+        BOOST_CHECK(obj.as<std::vector<char> >() == v1);
+        v1.front() = 42;
+        // obj refer to v1
+        BOOST_CHECK_EQUAL(obj.as<std::vector<char> >().front(), 42);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(vector_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        std::vector<unsigned char> v1;
+        v1.push_back(1);
+        for (unsigned int i = 1; i < kElements; i++)
+            v1.push_back(static_cast<unsigned char>(i));
+        msgpack::object obj(v1);
+        BOOST_CHECK(obj.as<std::vector<unsigned char> >() == v1);
+        v1.front() = 42;
+        // obj refer to v1
+        BOOST_CHECK_EQUAL(obj.as<std::vector<unsigned char> >().front(), 42);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(raw_ref)
+{
+    std::string s = "abc";
+    msgpack::type::raw_ref v(s.data(), static_cast<uint32_t>(s.size()));
+    msgpack::zone z;
+    msgpack::object obj(v);
+    BOOST_CHECK(obj.as<msgpack::type::raw_ref>() == v);
+    s[0] = 'd';
+    BOOST_CHECK(obj.as<msgpack::type::raw_ref>() == v);
+}
+
+#if MSGPACK_CPP_VERSION >= 201703
+
+BOOST_AUTO_TEST_CASE(array_char)
+{
+    typedef std::array<char, kElements> test_t;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        test_t v1;
+        v1[0] = 1;
+        for (unsigned int i = 1; i < kElements; i++)
+            v1[i] = static_cast<char>(rand());
+        msgpack::object obj(v1);
+        BOOST_CHECK(obj.as<test_t>() == v1);
+        v1.front() = 42;
+        // obj refer to v1
+        BOOST_CHECK_EQUAL(obj.as<test_t>().front(), 42);
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(array_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    typedef std::array<unsigned char, kElements> test_t;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        test_t v1;
+        v1[0] = 1;
+        for (unsigned int i = 1; i < kElements; i++)
+            v1[i] = static_cast<unsigned char>(rand());
+        msgpack::object obj(v1);
+        BOOST_CHECK(obj.as<test_t>() == v1);
+        v1.front() = 42;
+        // obj refer to v1
+        BOOST_CHECK_EQUAL(obj.as<test_t>().front(), 42);
+    }
+}
+
+#endif // MSGPACK_CPP_VERSION >= 201703

test/pack_unpack.cpp

@@ -1,26 +1,18 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE pack_unpack
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include <sstream>
 
-TEST(pack, num)
+BOOST_AUTO_TEST_CASE(pack_num)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
 }
 
 
-TEST(pack, vector)
+BOOST_AUTO_TEST_CASE(pack_vector)
 {
     msgpack::sbuffer sbuf;
     std::vector<int> vec;
@@ -31,7 +23,7 @@ TEST(pack, vector)
 }
 
 
-TEST(pack, to_ostream)
+BOOST_AUTO_TEST_CASE(pack_to_ostream)
 {
     std::ostringstream stream;
     msgpack::pack(stream, 1);
@@ -53,7 +45,7 @@ struct myclass {
 };
 
 
-TEST(pack, myclass)
+BOOST_AUTO_TEST_CASE(pack_myclass)
 {
     msgpack::sbuffer sbuf;
     myclass m(1, "msgpack");
@@ -61,16 +53,16 @@ TEST(pack, myclass)
 }
 
 
-TEST(unpack, int_ret_no_offset_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_ret_no_offset_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 }
 
-TEST(unpack, int_ret_offset_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_ret_offset_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -78,22 +70,22 @@ TEST(unpack, int_ret_offset_no_ref)
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
-TEST(unpack, int_ret_no_offset_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_ret_no_offset_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     bool referenced;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(unpack, int_ret_offset_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_ret_offset_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -101,23 +93,23 @@ TEST(unpack, int_ret_offset_ref)
     bool referenced;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
 
-TEST(unpack, int_no_offset_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_no_offset_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     msgpack::object_handle oh;
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size());
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 }
 
-TEST(unpack, int_offset_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_offset_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -126,11 +118,11 @@ TEST(unpack, int_offset_no_ref)
     std::size_t off = 0;
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
-TEST(unpack, int_no_offset_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_no_offset_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -138,11 +130,11 @@ TEST(unpack, int_no_offset_ref)
     bool referenced;
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), referenced);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(unpack, int_offset_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_offset_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -151,14 +143,14 @@ TEST(unpack, int_offset_ref)
     bool referenced;
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), off, referenced);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
 #if MSGPACK_DEFAULT_API_VERSION == 1
 
-TEST(unpack, int_pointer_off_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_pointer_off_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -175,11 +167,11 @@ TEST(unpack, int_pointer_off_no_ref)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
-TEST(unpack, int_pointer_off_no_ref_explicit)
+BOOST_AUTO_TEST_CASE(unpack_int_pointer_off_no_ref_explicit)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -196,11 +188,11 @@ TEST(unpack, int_pointer_off_no_ref_explicit)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
-TEST(unpack, int_pointer_no_off_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_pointer_no_off_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -216,11 +208,11 @@ TEST(unpack, int_pointer_no_off_ref)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(unpack, int_pointer_off_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_pointer_off_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -237,13 +229,13 @@ TEST(unpack, int_pointer_off_ref)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
 
-TEST(unpack, int_default_null_pointer)
+BOOST_AUTO_TEST_CASE(unpack_int_default_null_pointer)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -258,22 +250,22 @@ TEST(unpack, int_default_null_pointer)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 }
 
 #endif // MSGPACK_DEFAULT_API_VERSION == 1
 
-TEST(unpack, int_zone_no_offset_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_zone_no_offset_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
 
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size());
-    EXPECT_EQ(1, obj.as<int>());
+    BOOST_CHECK_EQUAL(1, obj.as<int>());
 }
 
-TEST(unpack, int_zone_offset_no_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_zone_offset_no_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -282,11 +274,11 @@ TEST(unpack, int_zone_offset_no_ref)
 
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off);
-    EXPECT_EQ(1, obj.as<int>());
+    BOOST_CHECK_EQUAL(1, obj.as<int>());
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
-TEST(unpack, int_zone_no_offset_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_zone_no_offset_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -294,11 +286,11 @@ TEST(unpack, int_zone_no_offset_ref)
 
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), referenced);
-    EXPECT_EQ(1, obj.as<int>());
+    BOOST_CHECK_EQUAL(1, obj.as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(unpack, int_zone_offset_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_zone_offset_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -307,13 +299,13 @@ TEST(unpack, int_zone_offset_ref)
 
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off, referenced);
-    EXPECT_EQ(1, obj.as<int>());
+    BOOST_CHECK_EQUAL(1, obj.as<int>());
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
 
-TEST(unpack, sequence)
+BOOST_AUTO_TEST_CASE(unpack_sequence)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -325,19 +317,19 @@ TEST(unpack, sequence)
     msgpack::object_handle oh;
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
-    EXPECT_EQ(2, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(2, oh.get().as<int>());
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
-    EXPECT_EQ(3, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(3, oh.get().as<int>());
 
-    EXPECT_EQ(off, sbuf.size());
+    BOOST_CHECK_EQUAL(off, sbuf.size());
 }
 
 
-TEST(unpack, convert_to_object_handle)
+BOOST_AUTO_TEST_CASE(unpack_convert_to_object_handle)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -345,29 +337,29 @@ TEST(unpack, convert_to_object_handle)
 
     msgpack::unpack(msg, sbuf.data(), sbuf.size());
     msgpack::object_handle oh(msgpack::move(msg));
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 
 }
 
-TEST(unpack, convert_to_object_handle_direct)
+BOOST_AUTO_TEST_CASE(unpack_convert_to_object_handle_direct)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     msgpack::object_handle oh(msgpack::unpack(sbuf.data(), sbuf.size()));
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 
 }
 
-TEST(unpack, convert_to_object_handle_direct_implicit)
+BOOST_AUTO_TEST_CASE(unpack_convert_to_object_handle_direct_implicit)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 
 }
 
-TEST(unpack, insufficient_bytes_ref)
+BOOST_AUTO_TEST_CASE(unpack_insufficient_bytes_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 255); // uint8 (2bytes)
@@ -377,19 +369,19 @@ TEST(unpack, insufficient_bytes_ref)
     msgpack::object_handle oh;
     try {
         msgpack::unpack(oh, sbuf.data(), 1, off);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::insufficient_bytes const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-        EXPECT_EQ(off, 0u);
+        BOOST_CHECK_EQUAL(off, 0u);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-        EXPECT_EQ(1u, off);
+        BOOST_CHECK_EQUAL(1u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
     }
 }
 
-TEST(unpack, insufficient_bytes_object_handle)
+BOOST_AUTO_TEST_CASE(unpack_insufficient_bytes_object_handle)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 255); // uint8 (2bytes)
@@ -398,19 +390,19 @@ TEST(unpack, insufficient_bytes_object_handle)
 
     try {
         msgpack::object_handle oh(msgpack::unpack(sbuf.data(), 1, off));
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::insufficient_bytes const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-        EXPECT_EQ(off, 0u);
+        BOOST_CHECK_EQUAL(off, 0u);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-        EXPECT_EQ(1u, off);
+        BOOST_CHECK_EQUAL(1u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
     }
 }
 
-TEST(unpack, insufficient_bytes_zone)
+BOOST_AUTO_TEST_CASE(unpack_insufficient_bytes_zone)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 255); // uint8 (2bytes)
@@ -420,19 +412,19 @@ TEST(unpack, insufficient_bytes_zone)
     try {
         msgpack::zone z;
         msgpack::unpack(z, sbuf.data(), 1, off);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::insufficient_bytes const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-        EXPECT_EQ(off, 0u);
+        BOOST_CHECK_EQUAL(off, 0u);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-        EXPECT_EQ(1u, off);
+        BOOST_CHECK_EQUAL(1u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
     }
 }
 
-TEST(unpack, parse_error)
+BOOST_AUTO_TEST_CASE(unpack_parse_error)
 {
     msgpack::sbuffer sbuf;
 
@@ -443,15 +435,15 @@ TEST(unpack, parse_error)
     msgpack::object_handle oh;
     try {
         msgpack::unpack(oh, sbuf.data(), sbuf.size());
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::parse_error const&) {
         thrown = true;
     }
-    EXPECT_TRUE(thrown);
+    BOOST_CHECK(thrown);
 }
 
-TEST(unpack, returned_parse_error)
+BOOST_AUTO_TEST_CASE(unpack_returned_parse_error)
 {
     msgpack::sbuffer sbuf;
 
@@ -461,15 +453,15 @@ TEST(unpack, returned_parse_error)
     bool thrown = false;
     try {
         msgpack::unpack(sbuf.data(), sbuf.size());
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::parse_error const&) {
         thrown = true;
     }
-    EXPECT_TRUE(thrown);
+    BOOST_CHECK(thrown);
 }
 
-TEST(unpack, zone_parse_error)
+BOOST_AUTO_TEST_CASE(unpack_zone_parse_error)
 {
     msgpack::sbuffer sbuf;
 
@@ -480,34 +472,34 @@ TEST(unpack, zone_parse_error)
     msgpack::zone z;
     try {
         msgpack::unpack(z, sbuf.data(), sbuf.size());
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::parse_error const&) {
         thrown = true;
     }
-    EXPECT_TRUE(thrown);
+    BOOST_CHECK(thrown);
 }
 
-TEST(unpack, extra_bytes)
+BOOST_AUTO_TEST_CASE(unpack_extra_bytes)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size() + 1);
-    EXPECT_EQ(1, oh.get().as<int>());
+    BOOST_CHECK_EQUAL(1, oh.get().as<int>());
 }
 
-TEST(unpack, zone_extra_bytes)
+BOOST_AUTO_TEST_CASE(unpack_zone_extra_bytes)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
 
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size() + 1);
-    EXPECT_EQ(1, obj.as<int>());
+    BOOST_CHECK_EQUAL(1, obj.as<int>());
 }
 
-TEST(unpack, int_off_larger_than_length)
+BOOST_AUTO_TEST_CASE(unpack_int_off_larger_than_length)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -521,23 +513,23 @@ TEST(unpack, int_off_larger_than_length)
     catch (msgpack::insufficient_bytes const&) {
         thrown = true;
     }
-    EXPECT_TRUE(thrown);
+    BOOST_CHECK(thrown);
-    EXPECT_EQ(off, 2u);
+    BOOST_CHECK_EQUAL(off, 2u);
 }
 
-TEST(unpack, empty_array_fix)
+BOOST_AUTO_TEST_CASE(unpack_empty_array_fix)
 {
     std::string buf;
     buf.push_back(static_cast<char>(0x90u));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
-    EXPECT_EQ(oh.get().via.array.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
-    EXPECT_EQ(off, 1u);
+    BOOST_CHECK_EQUAL(off, 1u);
 }
 
-TEST(unpack, empty_array_16)
+BOOST_AUTO_TEST_CASE(unpack_empty_array_16)
 {
     std::string buf;
     buf.push_back(static_cast<char>(0xdcu));
@@ -546,12 +538,12 @@ TEST(unpack, empty_array_16)
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
-    EXPECT_EQ(oh.get().via.array.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
-    EXPECT_EQ(off, 3u);
+    BOOST_CHECK_EQUAL(off, 3u);
 }
 
-TEST(unpack, empty_array_32)
+BOOST_AUTO_TEST_CASE(unpack_empty_array_32)
 {
     std::string buf;
     buf.push_back(static_cast<char>(0xddu));
@@ -562,24 +554,24 @@ TEST(unpack, empty_array_32)
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
-    EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
-    EXPECT_EQ(oh.get().via.array.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
-    EXPECT_EQ(off, 5u);
+    BOOST_CHECK_EQUAL(off, 5u);
 }
 
-TEST(unpack, empty_map_fix)
+BOOST_AUTO_TEST_CASE(unpack_empty_map_fix)
 {
     std::string buf;
     buf.push_back(static_cast<char>(0x80u));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
-    EXPECT_EQ(oh.get().type, msgpack::type::MAP);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::MAP);
-    EXPECT_EQ(oh.get().via.map.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.map.size, 0u);
-    EXPECT_EQ(off, 1u);
+    BOOST_CHECK_EQUAL(off, 1u);
 }
 
-TEST(unpack, empty_map_16)
+BOOST_AUTO_TEST_CASE(unpack_empty_map_16)
 {
     std::string buf;
     buf.push_back(static_cast<char>(0xdeu));
@@ -588,12 +580,12 @@ TEST(unpack, empty_map_16)
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
-    EXPECT_EQ(oh.get().type, msgpack::type::MAP);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::MAP);
-    EXPECT_EQ(oh.get().via.map.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.map.size, 0u);
-    EXPECT_EQ(off, 3u);
+    BOOST_CHECK_EQUAL(off, 3u);
 }
 
-TEST(unpack, empty_map_32)
+BOOST_AUTO_TEST_CASE(unpack_empty_map_32)
 {
     std::string buf;
     buf.push_back(static_cast<char>(0xdfu));
@@ -604,7 +596,7 @@ TEST(unpack, empty_map_32)
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
-    EXPECT_EQ(oh.get().type, msgpack::type::MAP);
+    BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::MAP);
-    EXPECT_EQ(oh.get().via.map.size, 0u);
+    BOOST_CHECK_EQUAL(oh.get().via.map.size, 0u);
-    EXPECT_EQ(off, 5u);
+    BOOST_CHECK_EQUAL(off, 5u);
 }

test/raw.cpp

@@ -3,22 +3,14 @@
 #include <string>
 #include <sstream>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_RAW_REF
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-TEST(MSGPACK_RAW_REF, pack_unpack)
+BOOST_AUTO_TEST_CASE(pack_unpack)
 {
     std::string s = "ABC";
 
@@ -26,19 +18,19 @@ TEST(MSGPACK_RAW_REF, pack_unpack)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc4u));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0x03u));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x03u));
-    EXPECT_EQ(packed_str[2], 'A');
+    BOOST_CHECK_EQUAL(packed_str[2], 'A');
-    EXPECT_EQ(packed_str[3], 'B');
+    BOOST_CHECK_EQUAL(packed_str[3], 'B');
-    EXPECT_EQ(packed_str[4], 'C');
+    BOOST_CHECK_EQUAL(packed_str[4], 'C');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
+BOOST_AUTO_TEST_CASE(pack_unpack_8_l)
 {
     std::string s;
 
@@ -46,16 +38,16 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc4u));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00u));
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
+BOOST_AUTO_TEST_CASE(pack_unpack_8_h)
 {
     std::string s(0xff, 'A');
 
@@ -63,17 +55,17 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc4u));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0xffu));
-    EXPECT_EQ(packed_str[2], 'A');
+    BOOST_CHECK_EQUAL(packed_str[2], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
+BOOST_AUTO_TEST_CASE(pack_unpack_16_l)
 {
     std::string s(0xff+1, 'A');
 
@@ -81,18 +73,18 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xc5u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc5u));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0x01));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x01));
-    EXPECT_EQ(packed_str[2], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[3], 'A');
+    BOOST_CHECK_EQUAL(packed_str[3], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
+BOOST_AUTO_TEST_CASE(pack_unpack_16_h)
 {
     std::string s(0xffff, 'A');
 
@@ -100,18 +92,18 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xc5u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc5u));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0xffu));
-    EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
+    BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0xffu));
-    EXPECT_EQ(packed_str[3], 'A');
+    BOOST_CHECK_EQUAL(packed_str[3], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
+BOOST_AUTO_TEST_CASE(pack_unpack_32_l)
 {
     std::string s(0xffff+1, 'A');
 
@@ -119,20 +111,20 @@ TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xc6u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc6u));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[2], static_cast<char>(0x01));
+    BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x01));
-    EXPECT_EQ(packed_str[3], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[3], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[4], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[5], 'A');
+    BOOST_CHECK_EQUAL(packed_str[5], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_V4RAW_REF, pack_unpack)
+BOOST_AUTO_TEST_CASE(v4_pack_unpack)
 {
     std::string s = "ABC";
 
@@ -140,18 +132,18 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xa3u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xa3u));
-    EXPECT_EQ(packed_str[1], 'A');
+    BOOST_CHECK_EQUAL(packed_str[1], 'A');
-    EXPECT_EQ(packed_str[2], 'B');
+    BOOST_CHECK_EQUAL(packed_str[2], 'B');
-    EXPECT_EQ(packed_str[3], 'C');
+    BOOST_CHECK_EQUAL(packed_str[3], 'C');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
+BOOST_AUTO_TEST_CASE(v4_pack_unpack_fix_l)
 {
     std::string s;
 
@@ -159,15 +151,15 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xa0u));
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
+BOOST_AUTO_TEST_CASE(v4_pack_unpack_fix_h)
 {
     std::string s(0x1f, 'A');
 
@@ -175,16 +167,16 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xbfu));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xbfu));
-    EXPECT_EQ(packed_str[1], 'A');
+    BOOST_CHECK_EQUAL(packed_str[1], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
+BOOST_AUTO_TEST_CASE(v4_pack_unpack_16_l)
 {
     std::string s(0x1f+1, 'A');
 
@@ -192,18 +184,18 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xdau));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xdau));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00u));
-    EXPECT_EQ(packed_str[2], static_cast<char>(0x20u));
+    BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x20u));
-    EXPECT_EQ(packed_str[3], 'A');
+    BOOST_CHECK_EQUAL(packed_str[3], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
+BOOST_AUTO_TEST_CASE(v4_pack_unpack_16_h)
 {
     std::string s(0xffff, 'A');
 
@@ -211,18 +203,18 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xdau));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xdau));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0xffu));
-    EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
+    BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0xffu));
-    EXPECT_EQ(packed_str[3], 'A');
+    BOOST_CHECK_EQUAL(packed_str[3], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }
 
-TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
+BOOST_AUTO_TEST_CASE(v4_pack_unpack_32_l)
 {
     std::string s(0xffff+1, 'A');
 
@@ -230,15 +222,15 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
-    EXPECT_EQ(packed_str[0], static_cast<char>(0xdbu));
+    BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xdbu));
-    EXPECT_EQ(packed_str[1], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[2], static_cast<char>(0x01));
+    BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x01));
-    EXPECT_EQ(packed_str[3], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[3], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
+    BOOST_CHECK_EQUAL(packed_str[4], static_cast<char>(0x00));
-    EXPECT_EQ(packed_str[5], 'A');
+    BOOST_CHECK_EQUAL(packed_str[5], 'A');
 
     msgpack::object_handle oh =
         msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
-    EXPECT_TRUE(rr1 == rr2);
+    BOOST_CHECK(rr1 == rr2);
 }

test/reference.cpp

@@ -1,17 +1,9 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE reference
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+BOOST_AUTO_TEST_CASE(unpack_int)
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-TEST(reference, unpack_int)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -19,10 +11,10 @@ TEST(reference, unpack_int)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_string)
+BOOST_AUTO_TEST_CASE(unpack_string)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
@@ -30,10 +22,10 @@ TEST(reference, unpack_string)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_bin)
+BOOST_AUTO_TEST_CASE(unpack_bin)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -44,10 +36,10 @@ TEST(reference, unpack_bin)
     bool referenced = false;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_ext)
+BOOST_AUTO_TEST_CASE(unpack_ext)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -58,12 +50,12 @@ TEST(reference, unpack_ext)
     bool referenced = false;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
 bool never_called(msgpack::type::object_type, std::size_t, void*)
 {
-    EXPECT_TRUE(false);
+    BOOST_CHECK(false);
     return false;
 }
 
@@ -72,7 +64,7 @@ bool always_reference(msgpack::type::object_type, std::size_t, void*)
     return true;
 }
 
-TEST(reference, unpack_int_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -80,10 +72,10 @@ TEST(reference, unpack_int_ref)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_string_ref)
+BOOST_AUTO_TEST_CASE(unpack_string_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
@@ -91,10 +83,10 @@ TEST(reference, unpack_string_ref)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
-TEST(reference, unpack_bin_ref)
+BOOST_AUTO_TEST_CASE(unpack_bin_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -105,10 +97,10 @@ TEST(reference, unpack_bin_ref)
     bool referenced = false;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
-TEST(reference, unpack_ext_ref)
+BOOST_AUTO_TEST_CASE(unpack_ext_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -120,7 +112,7 @@ TEST(reference, unpack_ext_ref)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
 static void* s_p;
@@ -139,12 +131,12 @@ bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p)
         if (s >= 7) return true;
         break;
     default:
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     return false;
 }
 
-TEST(reference, unpack_int_sized_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_sized_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -154,11 +146,11 @@ TEST(reference, unpack_int_sized_ref)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(MSGPACK_NULLPTR, s_p);
+    BOOST_CHECK(MSGPACK_NULLPTR == s_p);
 }
 
-TEST(reference, unpack_string_sized_ref_4)
+BOOST_AUTO_TEST_CASE(unpack_string_sized_ref_4)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("1234"));
@@ -169,12 +161,12 @@ TEST(reference, unpack_string_sized_ref_4)
     // That is stored to s_p in sized_reference
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
     // compare the passed argument with stored s_p.
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_string_sized_ref_5)
+BOOST_AUTO_TEST_CASE(unpack_string_sized_ref_5)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("12345"));
@@ -184,12 +176,12 @@ TEST(reference, unpack_string_sized_ref_5)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
 
-TEST(reference, unpack_bin_sized_ref_5)
+BOOST_AUTO_TEST_CASE(unpack_bin_sized_ref_5)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -202,11 +194,11 @@ TEST(reference, unpack_bin_sized_ref_5)
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_bin_sized_ref_6)
+BOOST_AUTO_TEST_CASE(unpack_bin_sized_ref_6)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -218,11 +210,11 @@ TEST(reference, unpack_bin_sized_ref_6)
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_ext_sized_ref_6)
+BOOST_AUTO_TEST_CASE(unpack_ext_sized_ref_6)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -235,11 +227,11 @@ TEST(reference, unpack_ext_sized_ref_6)
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_ext_sized_ref_7)
+BOOST_AUTO_TEST_CASE(unpack_ext_sized_ref_7)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -252,14 +244,14 @@ TEST(reference, unpack_ext_sized_ref_7)
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
 // default reference function
 // STR, BIN, and EXT are always referenced, otherwise copied (converted).
 
-TEST(reference, unpacker_int)
+BOOST_AUTO_TEST_CASE(unpacker_int)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -271,11 +263,11 @@ TEST(reference, unpacker_int)
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpacker_string)
+BOOST_AUTO_TEST_CASE(unpacker_string)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("a"));
@@ -287,11 +279,11 @@ TEST(reference, unpacker_string)
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
-TEST(reference, unpacker_bin)
+BOOST_AUTO_TEST_CASE(unpacker_bin)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -306,11 +298,11 @@ TEST(reference, unpacker_bin)
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
-TEST(reference, unpacker_ext)
+BOOST_AUTO_TEST_CASE(unpacker_ext)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -326,13 +318,13 @@ TEST(reference, unpacker_ext)
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
 // pass user custom reference function
 
-TEST(reference, unpacker_int_sized_ref)
+BOOST_AUTO_TEST_CASE(unpacker_int_sized_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -345,12 +337,12 @@ TEST(reference, unpacker_int_sized_ref)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(MSGPACK_NULLPTR, s_p);
+    BOOST_CHECK(MSGPACK_NULLPTR == s_p);
 }
 
-TEST(reference, unpacker_string_sized_ref_4)
+BOOST_AUTO_TEST_CASE(unpacker_string_sized_ref_4)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("1234"));
@@ -363,12 +355,12 @@ TEST(reference, unpacker_string_sized_ref_4)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpacker_string_sized_ref_5)
+BOOST_AUTO_TEST_CASE(unpacker_string_sized_ref_5)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("12345"));
@@ -381,13 +373,13 @@ TEST(reference, unpacker_string_sized_ref_5)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
 
-TEST(reference, unpacker_bin_sized_ref_5)
+BOOST_AUTO_TEST_CASE(unpacker_bin_sized_ref_5)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -403,12 +395,12 @@ TEST(reference, unpacker_bin_sized_ref_5)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpacker_bin_sized_ref_6)
+BOOST_AUTO_TEST_CASE(unpacker_bin_sized_ref_6)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -424,12 +416,12 @@ TEST(reference, unpacker_bin_sized_ref_6)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpacker_ext_sized_ref_6)
+BOOST_AUTO_TEST_CASE(unpacker_ext_sized_ref_6)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -446,12 +438,12 @@ TEST(reference, unpacker_ext_sized_ref_6)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpacker_ext_sized_ref_7)
+BOOST_AUTO_TEST_CASE(unpacker_ext_sized_ref_7)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -468,7 +460,7 @@ TEST(reference, unpacker_ext_sized_ref_7)
     unp.buffer_consumed(sbuf.size());
     s_p = MSGPACK_NULLPTR;
     bool b = unp.next(oh, referenced);
-    EXPECT_TRUE(b);
+    BOOST_CHECK(b);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }

test/reference_cpp11.cpp

@@ -1,39 +1,31 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE reference
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(reference, unpack_int)
+BOOST_AUTO_TEST_CASE(unpack_int)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     bool referenced;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_string)
+BOOST_AUTO_TEST_CASE(unpack_string)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
     bool referenced;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_bin)
+BOOST_AUTO_TEST_CASE(unpack_bin)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -43,10 +35,10 @@ TEST(reference, unpack_bin)
 
     bool referenced;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_ext)
+BOOST_AUTO_TEST_CASE(unpack_ext)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -56,12 +48,12 @@ TEST(reference, unpack_ext)
     packer.pack_ext_body(buf, sizeof(buf));
     bool referenced;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
 bool never_called(msgpack::type::object_type, std::size_t, void*)
 {
-    EXPECT_TRUE(false);
+    BOOST_CHECK(false);
     return false;
 }
 
@@ -70,27 +62,27 @@ bool always_reference(msgpack::type::object_type, std::size_t, void*)
     return true;
 }
 
-TEST(reference, unpack_int_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     bool referenced;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
 }
 
-TEST(reference, unpack_string_ref)
+BOOST_AUTO_TEST_CASE(unpack_string_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
     bool referenced;
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
-TEST(reference, unpack_bin_ref)
+BOOST_AUTO_TEST_CASE(unpack_bin_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -100,10 +92,10 @@ TEST(reference, unpack_bin_ref)
 
     bool referenced;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
-TEST(reference, unpack_ext_ref)
+BOOST_AUTO_TEST_CASE(unpack_ext_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -113,7 +105,7 @@ TEST(reference, unpack_ext_ref)
     packer.pack_ext_body(buf, sizeof(buf));
     bool referenced;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
 }
 
 static void* s_p;
@@ -132,12 +124,12 @@ bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p)
         if (s >= 7) return true;
         break;
     default:
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     return false;
 }
 
-TEST(reference, unpack_int_sized_ref)
+BOOST_AUTO_TEST_CASE(unpack_int_sized_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
@@ -145,11 +137,11 @@ TEST(reference, unpack_int_sized_ref)
     bool referenced;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(MSGPACK_NULLPTR, s_p);
+    BOOST_CHECK_EQUAL(MSGPACK_NULLPTR, s_p);
 }
 
-TEST(reference, unpack_string_sized_ref_4)
+BOOST_AUTO_TEST_CASE(unpack_string_sized_ref_4)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("1234"));
@@ -159,12 +151,12 @@ TEST(reference, unpack_string_sized_ref_4)
     // the last argument sbuf is any pointer as a user data.
     // That is stored to s_p in sized_reference
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
     // compare the passed argument with stored s_p.
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_string_sized_ref_5)
+BOOST_AUTO_TEST_CASE(unpack_string_sized_ref_5)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("12345"));
@@ -172,12 +164,12 @@ TEST(reference, unpack_string_sized_ref_5)
     bool referenced;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
 
-TEST(reference, unpack_bin_sized_ref_5)
+BOOST_AUTO_TEST_CASE(unpack_bin_sized_ref_5)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -188,11 +180,11 @@ TEST(reference, unpack_bin_sized_ref_5)
     bool referenced;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_bin_sized_ref_6)
+BOOST_AUTO_TEST_CASE(unpack_bin_sized_ref_6)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -203,11 +195,11 @@ TEST(reference, unpack_bin_sized_ref_6)
     bool referenced;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_ext_sized_ref_6)
+BOOST_AUTO_TEST_CASE(unpack_ext_sized_ref_6)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -219,11 +211,11 @@ TEST(reference, unpack_ext_sized_ref_6)
     bool referenced;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_FALSE(referenced);
+    BOOST_CHECK(!referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
-TEST(reference, unpack_ext_sized_ref_7)
+BOOST_AUTO_TEST_CASE(unpack_ext_sized_ref_7)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> packer(sbuf);
@@ -235,8 +227,8 @@ TEST(reference, unpack_ext_sized_ref_7)
     bool referenced;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
-    EXPECT_TRUE(referenced);
+    BOOST_CHECK(referenced);
-    EXPECT_EQ(&sbuf, s_p);
+    BOOST_CHECK_EQUAL(&sbuf, s_p);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)

test/reference_wrapper_cpp11.cpp

@@ -1,16 +1,8 @@
 #include <msgpack.hpp>
 #include <sstream>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_REFERENCE_WRAPPER
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -18,7 +10,7 @@
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert)
+BOOST_AUTO_TEST_CASE(pack_convert)
 {
     int i1 = 42;
     std::reference_wrapper<int> val1(i1);
@@ -29,10 +21,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert)
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
-    EXPECT_EQ(i1, i2);
+    BOOST_CHECK_EQUAL(i1, i2);
 }
 
-TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
+BOOST_AUTO_TEST_CASE(pack_convert_const)
 {
     const int i1 = 42;
     std::reference_wrapper<const int> val1(i1);
@@ -43,10 +35,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
-    EXPECT_EQ(i1, i2);
+    BOOST_CHECK_EQUAL(i1, i2);
 }
 
-TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
+BOOST_AUTO_TEST_CASE(pack_vector)
 {
     int i1 = 42;
     std::vector<std::reference_wrapper<int>> val1{i1};
@@ -55,11 +47,11 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
     std::string const& str = ss.str();
     msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     std::vector<int> val2 = oh.get().as<std::vector<int>>();
-    EXPECT_EQ(val2.size(), static_cast<size_t>(1));
+    BOOST_CHECK_EQUAL(val2.size(), static_cast<size_t>(1));
-    EXPECT_EQ(val1[0], val2[0]);
+    BOOST_CHECK_EQUAL(val1[0], val2[0]);
 }
 
-TEST(MSGPACK_REFERENCE_WRAPPER, object)
+BOOST_AUTO_TEST_CASE(object)
 {
     int i1 = 42;
     std::reference_wrapper<int> val1(i1);
@@ -67,10 +59,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object)
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     o.convert(val2);
-    EXPECT_EQ(i1, i2);
+    BOOST_CHECK_EQUAL(i1, i2);
 }
 
-TEST(MSGPACK_REFERENCE_WRAPPER, object_const)
+BOOST_AUTO_TEST_CASE(object_const)
 {
     const int i1 = 42;
     std::reference_wrapper<const int> val1(i1);
@@ -78,10 +70,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object_const)
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     o.convert(val2);
-    EXPECT_EQ(i1, i2);
+    BOOST_CHECK_EQUAL(i1, i2);
 }
 
-TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone)
+BOOST_AUTO_TEST_CASE(object_with_zone)
 {
     std::string s1 = "ABC";
     std::reference_wrapper<std::string> val1(s1);
@@ -90,10 +82,10 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone)
     std::string s2 = "DE";
     std::reference_wrapper<std::string> val2(s2);
     o.convert(val2);
-    EXPECT_EQ(s1, s2);
+    BOOST_CHECK_EQUAL(s1, s2);
 }
 
-TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone_const)
+BOOST_AUTO_TEST_CASE(object_with_zone_const)
 {
     const std::string s1 = "ABC";
     std::reference_wrapper<const std::string> val1(s1);
@@ -102,7 +94,7 @@ TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone_const)
     std::string s2 = "DE";
     std::reference_wrapper<std::string> val2(s2);
     o.convert(val2);
-    EXPECT_EQ(s1, s2);
+    BOOST_CHECK_EQUAL(s1, s2);
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)

test/shared_ptr_cpp11.cpp

@@ -2,24 +2,15 @@
 #include <sstream>
 #include <iterator>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE SHARED_PTR
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(SHARED_PTR, pack_convert_nil)
+BOOST_AUTO_TEST_CASE(pack_convert_nil)
 {
     std::stringstream ss;
     std::shared_ptr<int> val1;
@@ -28,10 +19,10 @@ TEST(SHARED_PTR, pack_convert_nil)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(SHARED_PTR, pack_convert_int)
+BOOST_AUTO_TEST_CASE(pack_convert_int)
 {
     std::stringstream ss;
     std::shared_ptr<int> val1(new int(1));
@@ -40,54 +31,54 @@ TEST(SHARED_PTR, pack_convert_int)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
-TEST(SHARED_PTR, object_nil)
+BOOST_AUTO_TEST_CASE(object_nil)
 {
     std::shared_ptr<int> val1;
     msgpack::object obj(val1);
     std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(SHARED_PTR, object_int)
+BOOST_AUTO_TEST_CASE(object_int)
 {
     std::shared_ptr<int> val1(new int(1));
     msgpack::object obj(val1);
     std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
 // Compile error as expected
 // object::with_zone is required not object
 /*
-TEST(SHARED_PTR, object_vector)
+BOOST_AUTO_TEST_CASE(object_vector)
 {
     typedef std::shared_ptr<std::vector<int>> ovi_t;
     ovi_t val1(new std::vector<int>());
     msgpack::object obj(val1);
     ovi_t  val2 = obj.as<ovi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 */
 
-TEST(SHARED_PTR, object_with_zone_nil)
+BOOST_AUTO_TEST_CASE(object_with_zone_nil)
 {
     msgpack::zone z;
     std::shared_ptr<int> val1;
     msgpack::object obj(val1, z);
     std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(SHARED_PTR, object_with_zone_int)
+BOOST_AUTO_TEST_CASE(object_with_zone_int)
 {
     msgpack::zone z;
     std::shared_ptr<int> val1(new int(1));
     msgpack::object obj(val1, z);
     std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
 struct no_def_con {
@@ -120,7 +111,7 @@ struct as<no_def_con> {
 } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
 } // msgpack
 
-TEST(SHARED_PTR, pack_convert_nil_no_def_con)
+BOOST_AUTO_TEST_CASE(pack_convert_nil_no_def_con)
 {
     std::stringstream ss;
     std::shared_ptr<no_def_con> val1(new no_def_con(1));
@@ -129,7 +120,7 @@ TEST(SHARED_PTR, pack_convert_nil_no_def_con)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::shared_ptr<no_def_con> val2 = oh.get().as<std::shared_ptr<no_def_con>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
 

test/size_equal_only.cpp

@@ -1,18 +1,10 @@
 #include <sstream>
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE size_equal_only
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+BOOST_AUTO_TEST_CASE(array)
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-TEST(size_equal_only, array)
 {
     std::stringstream ss;
     int buf[3] = { 1, 2, 3 };
@@ -24,35 +16,35 @@ TEST(size_equal_only, array)
 
     int ret_buf1[3];
     oh.get().convert(ret_buf1);
-    EXPECT_EQ(buf[0], ret_buf1[0]);
+    BOOST_CHECK_EQUAL(buf[0], ret_buf1[0]);
-    EXPECT_EQ(buf[1], ret_buf1[1]);
+    BOOST_CHECK_EQUAL(buf[1], ret_buf1[1]);
-    EXPECT_EQ(buf[2], ret_buf1[2]);
+    BOOST_CHECK_EQUAL(buf[2], ret_buf1[2]);
 
     int ret_buf2[4];
     oh.get().convert(ret_buf2);
-    EXPECT_EQ(buf[0], ret_buf2[0]);
+    BOOST_CHECK_EQUAL(buf[0], ret_buf2[0]);
-    EXPECT_EQ(buf[1], ret_buf2[1]);
+    BOOST_CHECK_EQUAL(buf[1], ret_buf2[1]);
-    EXPECT_EQ(buf[2], ret_buf2[2]);
+    BOOST_CHECK_EQUAL(buf[2], ret_buf2[2]);
 
     int ret_buf3[3];
     msgpack::type::size_equal_only<int[3]> ret_seo3(ret_buf3);
     oh.get().convert(ret_seo3);
-    EXPECT_EQ(buf[0], ret_buf3[0]);
+    BOOST_CHECK_EQUAL(buf[0], ret_buf3[0]);
-    EXPECT_EQ(buf[1], ret_buf3[1]);
+    BOOST_CHECK_EQUAL(buf[1], ret_buf3[1]);
-    EXPECT_EQ(buf[2], ret_buf3[2]);
+    BOOST_CHECK_EQUAL(buf[2], ret_buf3[2]);
 
     int ret_buf4[4];
     msgpack::type::size_equal_only<int[4]> ret_seo4(ret_buf4);
     try {
         oh.get().convert(ret_seo4);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 }
 
-TEST(size_equal_only, vector)
+BOOST_AUTO_TEST_CASE(vector)
 {
     std::stringstream ss;
     std::vector<int> buf;
@@ -68,28 +60,28 @@ TEST(size_equal_only, vector)
 
     std::vector<int> ret_buf1;
     oh.get().convert(ret_buf1);
-    EXPECT_EQ(buf, ret_buf1);
+    BOOST_CHECK(buf == ret_buf1);
 
 
     std::vector<int> ret_buf2;
     ret_buf2.resize(3);
     msgpack::type::size_equal_only<std::vector<int> > ret_seo2(ret_buf2);
     oh.get().convert(ret_seo2);
-    EXPECT_EQ(buf, ret_buf2);
+    BOOST_CHECK(buf == ret_buf2);
 
     std::vector<int> ret_buf3;
     ret_buf2.resize(4);
     msgpack::type::size_equal_only<std::vector<int> > ret_seo3(ret_buf3);
     try {
         oh.get().convert(ret_seo3);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 }
 
-TEST(size_equal_only, msgpack_tuple)
+BOOST_AUTO_TEST_CASE(msgpack_tuple)
 {
     std::stringstream ss;
     msgpack::type::tuple<int, bool, std::string> buf(1, false, "ABC");
@@ -102,52 +94,52 @@ TEST(size_equal_only, msgpack_tuple)
 
     msgpack::type::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
-    EXPECT_EQ(buf.get<0>(), ret_buf1.get<0>());
+    BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf1.get<0>());
-    EXPECT_EQ(buf.get<1>(), ret_buf1.get<1>());
+    BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf1.get<1>());
-    EXPECT_EQ(buf.get<2>(), ret_buf1.get<2>());
+    BOOST_CHECK_EQUAL(buf.get<2>(), ret_buf1.get<2>());
 
     msgpack::type::tuple<int, bool, std::string> ret_buf2;
     msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string> > ret_seo2(ret_buf2);
     oh.get().convert(ret_seo2);
-    EXPECT_EQ(buf.get<0>(), ret_buf2.get<0>());
+    BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf2.get<0>());
-    EXPECT_EQ(buf.get<1>(), ret_buf2.get<1>());
+    BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf2.get<1>());
-    EXPECT_EQ(buf.get<2>(), ret_buf2.get<2>());
+    BOOST_CHECK_EQUAL(buf.get<2>(), ret_buf2.get<2>());
 
     msgpack::type::tuple<int, bool, std::string, int> ret_buf3;
     oh.get().convert(ret_buf3);
-    EXPECT_EQ(buf.get<0>(), ret_buf3.get<0>());
+    BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf3.get<0>());
-    EXPECT_EQ(buf.get<1>(), ret_buf3.get<1>());
+    BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf3.get<1>());
-    EXPECT_EQ(buf.get<2>(), ret_buf3.get<2>());
+    BOOST_CHECK_EQUAL(buf.get<2>(), ret_buf3.get<2>());
 
     msgpack::type::tuple<int, bool, std::string, int> ret_buf4;
     msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string, int> > ret_seo4(ret_buf4);
     try {
         oh.get().convert(ret_seo4);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 
     msgpack::type::tuple<int, bool, std::string> ret_buf5;
     oh.get().convert(ret_buf5);
-    EXPECT_EQ(buf.get<0>(), ret_buf5.get<0>());
+    BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf5.get<0>());
-    EXPECT_EQ(buf.get<1>(), ret_buf5.get<1>());
+    BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf5.get<1>());
 
     msgpack::type::tuple<int, bool, std::string, int> ret_buf6;
     msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string, int> > ret_seo6(ret_buf6);
     try {
         oh.get().convert(ret_seo6);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 }
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(size_equal_only, tuple)
+BOOST_AUTO_TEST_CASE(tuple)
 {
     std::stringstream ss;
     std::tuple<int, bool, std::string> buf(1, false, "ABC");
@@ -160,42 +152,42 @@ TEST(size_equal_only, tuple)
 
     std::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
-    EXPECT_EQ(buf, ret_buf1);
+    BOOST_CHECK(buf == ret_buf1);
 
     std::tuple<int, bool, std::string> ret_buf2;
     auto ret_seo2 = msgpack::type::make_size_equal_only(ret_buf2);
     oh.get().convert(ret_seo2);
-    EXPECT_EQ(buf, ret_buf2);
+    BOOST_CHECK(buf == ret_buf2);
 
     std::tuple<int, bool, std::string, int> ret_buf3;
     oh.get().convert(ret_buf3);
-    EXPECT_EQ(std::get<0>(buf), std::get<0>(ret_buf3));
+    BOOST_CHECK_EQUAL(std::get<0>(buf), std::get<0>(ret_buf3));
-    EXPECT_EQ(std::get<1>(buf), std::get<1>(ret_buf3));
+    BOOST_CHECK_EQUAL(std::get<1>(buf), std::get<1>(ret_buf3));
-    EXPECT_EQ(std::get<2>(buf), std::get<2>(ret_buf3));
+    BOOST_CHECK_EQUAL(std::get<2>(buf), std::get<2>(ret_buf3));
 
     std::tuple<int, bool, std::string, int> ret_buf4;
     auto ret_seo4 = msgpack::type::make_size_equal_only(ret_buf4);
     try {
         oh.get().convert(ret_seo4);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 
     std::tuple<int, bool, std::string> ret_buf5;
     oh.get().convert(ret_buf5);
-    EXPECT_EQ(std::get<0>(buf), std::get<0>(ret_buf5));
+    BOOST_CHECK_EQUAL(std::get<0>(buf), std::get<0>(ret_buf5));
-    EXPECT_EQ(std::get<1>(buf), std::get<1>(ret_buf5));
+    BOOST_CHECK_EQUAL(std::get<1>(buf), std::get<1>(ret_buf5));
 
     std::tuple<int, bool, std::string, int> ret_buf6;
     auto ret_seo6 = msgpack::type::make_size_equal_only(ret_buf6);
     try {
         oh.get().convert(ret_seo6);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 }
 
@@ -213,7 +205,7 @@ struct foo2 {
     MSGPACK_DEFINE(seo);
 };
 
-TEST(size_equal_only, custom_class)
+BOOST_AUTO_TEST_CASE(custom_class)
 {
     std::stringstream ss;
     foo1 f1(42, true);
@@ -224,10 +216,10 @@ TEST(size_equal_only, custom_class)
     foo2 f2(123, false, "ABC");
     try {
         oh.get().convert(f2);
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
 }
 

test/streaming.cpp

@@ -1,19 +1,11 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE streaming
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include <sstream>
 
-TEST(streaming, basic)
+BOOST_AUTO_TEST_CASE(basic)
 {
     msgpack::sbuffer buffer;
 
@@ -44,25 +36,25 @@ TEST(streaming, basic)
             msgpack::object obj = oh.get();
             switch(count++) {
             case 0:
-                EXPECT_EQ(1, obj.as<int>());
+                BOOST_CHECK_EQUAL(1, obj.as<int>());
                 break;
             case 1:
-                EXPECT_EQ(2, obj.as<int>());
+                BOOST_CHECK_EQUAL(2, obj.as<int>());
                 break;
             case 2:
-                EXPECT_EQ(3, obj.as<int>());
+                BOOST_CHECK_EQUAL(3, obj.as<int>());
                 return;
             }
         }
 
-        EXPECT_TRUE(input < eof);
+        BOOST_CHECK(input < eof);
     }
 }
 
 // obsolete
 #if MSGPACK_DEFAULT_API_VERSION == 1
 
-TEST(streaming, basic_pointer)
+BOOST_AUTO_TEST_CASE(basic_pointer)
 {
     msgpack::sbuffer buffer;
 
@@ -100,18 +92,18 @@ TEST(streaming, basic_pointer)
             msgpack::object obj = oh.get();
             switch(count++) {
             case 0:
-                EXPECT_EQ(1, obj.as<int>());
+                BOOST_CHECK_EQUAL(1, obj.as<int>());
                 break;
             case 1:
-                EXPECT_EQ(2, obj.as<int>());
+                BOOST_CHECK_EQUAL(2, obj.as<int>());
                 break;
             case 2:
-                EXPECT_EQ(3, obj.as<int>());
+                BOOST_CHECK_EQUAL(3, obj.as<int>());
                 return;
             }
         }
 
-        EXPECT_TRUE(input < eof);
+        BOOST_CHECK(input < eof);
     }
 }
 
@@ -119,7 +111,7 @@ TEST(streaming, basic_pointer)
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(streaming, move)
+BOOST_AUTO_TEST_CASE(move)
 {
     msgpack::sbuffer buffer;
 
@@ -151,18 +143,18 @@ TEST(streaming, move)
             msgpack::object obj = oh.get();
             switch(count++) {
             case 0:
-                EXPECT_EQ(1, obj.as<int>());
+                BOOST_CHECK_EQUAL(1, obj.as<int>());
                 break;
             case 1:
-                EXPECT_EQ(2, obj.as<int>());
+                BOOST_CHECK_EQUAL(2, obj.as<int>());
                 break;
             case 2:
-                EXPECT_EQ(3, obj.as<int>());
+                BOOST_CHECK_EQUAL(3, obj.as<int>());
                 return;
             }
         }
 
-        EXPECT_TRUE(input < eof);
+        BOOST_CHECK(input < eof);
         pac = std::move(pac_in);
     }
 }
@@ -200,7 +192,7 @@ public:
 
     void on_message(msgpack::object obj, msgpack::unique_ptr<msgpack::zone>)
     {
-        EXPECT_EQ(expect, obj.as<int>());
+        BOOST_CHECK_EQUAL(expect, obj.as<int>());
     }
 
     int expect;
@@ -210,7 +202,7 @@ private:
     msgpack::unpacker pac;
 };
 
-TEST(streaming, event)
+BOOST_AUTO_TEST_CASE(event)
 {
     std::stringstream stream;
     msgpack::packer<std::ostream> pk(&stream);
@@ -234,7 +226,7 @@ TEST(streaming, event)
 #if MSGPACK_DEFAULT_API_VERSION == 1
 
 // backward compatibility
-TEST(streaming, basic_compat)
+BOOST_AUTO_TEST_CASE(basic_compat)
 {
     std::ostringstream stream;
     msgpack::packer<std::ostream> pk(&stream);
@@ -261,13 +253,13 @@ TEST(streaming, basic_compat)
 
             switch(count++) {
             case 0:
-                EXPECT_EQ(1, obj.as<int>());
+                BOOST_CHECK_EQUAL(1, obj.as<int>());
                 break;
             case 1:
-                EXPECT_EQ(2, obj.as<int>());
+                BOOST_CHECK_EQUAL(2, obj.as<int>());
                 break;
             case 2:
-                EXPECT_EQ(3, obj.as<int>());
+                BOOST_CHECK_EQUAL(3, obj.as<int>());
                 return;
             }
 
@@ -310,7 +302,7 @@ public:
 
     void on_message(msgpack::object obj, msgpack::unique_ptr<msgpack::zone>)
     {
-        EXPECT_EQ(expect, obj.as<int>());
+        BOOST_CHECK_EQUAL(expect, obj.as<int>());
     }
 
     int expect;
@@ -320,7 +312,7 @@ private:
     msgpack::unpacker pac;
 };
 
-TEST(streaming, event_compat)
+BOOST_AUTO_TEST_CASE(event_compat)
 {
     std::stringstream stream;
     msgpack::packer<std::ostream> pk(&stream);

test/test_allocator.hpp

@@ -11,6 +11,8 @@
 #ifndef TEST_ALLOCATOR_HPP
 #define TEST_ALLOCATOR_HPP
 
+#include <msgpack/cpp_version.hpp>
+
 #include <memory>
 
 namespace test {
@@ -21,17 +23,17 @@ struct allocator {
     typedef typename std::allocator<T>::size_type size_type;
     typedef typename std::allocator<T>::difference_type difference_type;
     template <class U> struct rebind { typedef allocator<U> other; };
-#if __cplusplus <= 201703
+#if MSGPACK_CPP_VERSION <= 201703
     typedef typename std::allocator<T>::pointer pointer;
     typedef typename std::allocator<T>::reference reference;
     typedef typename std::allocator<T>::const_pointer const_pointer;
     typedef typename std::allocator<T>::const_reference const_reference;
-#else // __cplusplus <= 201703
+#else // MSGPACK_CPP_VERSION <= 201703
     typedef value_type* pointer;
     typedef value_type& reference;
     typedef const value_type* const_pointer;
     typedef const value_type& const_reference;
-#endif // __cplusplus <= 201703
+#endif // MSGPACK_CPP_VERSION <= 201703
 #if defined(MSGPACK_USE_CPP03)
     allocator() throw() {}
     allocator (const allocator& alloc) throw()
@@ -52,13 +54,13 @@ struct allocator {
     template <class U>
     allocator (const allocator<U>& alloc) noexcept
         :alloc_(alloc.alloc_) {}
-#if __cplusplus <= 201703
+#if MSGPACK_CPP_VERSION <= 201703
     template <class U, class... Args>
     void construct (U* p, Args&&... args) {
         return alloc_.construct(p, std::forward<Args>(args)...);
     }
     size_type max_size() const noexcept { return alloc_.max_size(); }
-#else // __cplusplus <= 201703
+#else // MSGPACK_CPP_VERSION <= 201703
     template <class U, class... Args>
     void construct (U* p, Args&&... args) {
         return std::allocator_traits<decltype(alloc_)>::construct(alloc_, p, std::forward<Args>(args)...);
@@ -66,7 +68,7 @@ struct allocator {
     size_type max_size() const noexcept {
         return std::allocator_traits<decltype(alloc_)>::max_size(alloc_);
     }
-#endif // __cplusplus <= 201703
+#endif // MSGPACK_CPP_VERSION <= 201703
 #endif // defined(MSGPACK_USE_CPP03)
     pointer allocate (size_type n) {
         return alloc_.allocate(n);
@@ -75,15 +77,15 @@ struct allocator {
         return alloc_.deallocate(p, n);
     }
 
-#if __cplusplus <= 201703
+#if MSGPACK_CPP_VERSION <= 201703
     void destroy (pointer p) {
         alloc_.destroy(p);
     }
-#else // __cplusplus <= 201703
+#else // MSGPACK_CPP_VERSION <= 201703
     void destroy (pointer p) {
         std::allocator_traits<decltype(alloc_)>::destroy(alloc_, p);
     }
-#endif // __cplusplus <= 201703
+#endif // MSGPACK_CPP_VERSION <= 201703
 
     std::allocator<T> alloc_;
 };

test/unique_ptr_cpp11.cpp

@@ -2,16 +2,8 @@
 #include <sstream>
 #include <iterator>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE UNIQUE_PTR
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -19,7 +11,7 @@
 
 #if !defined(MSGPACK_USE_CPP03)
 
-TEST(UNIQUE_PTR, pack_convert_nil)
+BOOST_AUTO_TEST_CASE(pack_convert_nil)
 {
     std::stringstream ss;
     std::unique_ptr<int> val1;
@@ -28,10 +20,10 @@ TEST(UNIQUE_PTR, pack_convert_nil)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(UNIQUE_PTR, pack_convert_int)
+BOOST_AUTO_TEST_CASE(pack_convert_int)
 {
     std::stringstream ss;
     std::unique_ptr<int> val1(new int(1));
@@ -40,54 +32,54 @@ TEST(UNIQUE_PTR, pack_convert_int)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
-TEST(UNIQUE_PTR, object_nil)
+BOOST_AUTO_TEST_CASE(object_nil)
 {
     std::unique_ptr<int> val1;
     msgpack::object obj(val1);
     std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(UNIQUE_PTR, object_int)
+BOOST_AUTO_TEST_CASE(object_int)
 {
     std::unique_ptr<int> val1(new int(1));
     msgpack::object obj(val1);
     std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
 // Compile error as expected
 // object::with_zone is required not object
 /*
-TEST(UNIQUE_PTR, object_vector)
+BOOST_AUTO_TEST_CASE(object_vector)
 {
     typedef std::unique_ptr<std::vector<int>> ovi_t;
     ovi_t val1(new std::vector<int>());
     msgpack::object obj(val1);
     ovi_t  val2 = obj.as<ovi_t>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 */
 
-TEST(UNIQUE_PTR, object_with_zone_nil)
+BOOST_AUTO_TEST_CASE(object_with_zone_nil)
 {
     msgpack::zone z;
     std::unique_ptr<int> val1;
     msgpack::object obj(val1, z);
     std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
-    EXPECT_TRUE(val1 == val2);
+    BOOST_CHECK(val1 == val2);
 }
 
-TEST(UNIQUE_PTR, object_with_zone_int)
+BOOST_AUTO_TEST_CASE(object_with_zone_int)
 {
     msgpack::zone z;
     std::unique_ptr<int> val1(new int(1));
     msgpack::object obj(val1, z);
     std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
 struct no_def_con {
@@ -120,7 +112,7 @@ struct as<no_def_con> {
 } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
 } // msgpack
 
-TEST(UNIQUE_PTR, pack_convert_nil_no_def_con)
+BOOST_AUTO_TEST_CASE(pack_convert_nil_no_def_con)
 {
     std::stringstream ss;
     std::unique_ptr<no_def_con> val1(new no_def_con(1));
@@ -129,7 +121,7 @@ TEST(UNIQUE_PTR, pack_convert_nil_no_def_con)
     msgpack::object_handle oh =
         msgpack::unpack(str.data(), str.size());
     std::unique_ptr<no_def_con> val2 = oh.get().as<std::unique_ptr<no_def_con>>();
-    EXPECT_TRUE(*val1 == *val2);
+    BOOST_CHECK(*val1 == *val2);
 }
 
 

test/user_class.cpp

@@ -2,23 +2,13 @@
 #include <string>
 #include <cmath>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE MSGPACK_USER_DEFINED
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-
-
 using namespace std;
 
 const unsigned int kLoop = 1000;
@@ -57,7 +47,7 @@ public:
     MSGPACK_DEFINE(i, s);
 };
 
-TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
+BOOST_AUTO_TEST_CASE(simple_buffer_class)
 {
     for (unsigned int k = 0; k < kLoop; k++) {
         TestClass val1;
@@ -66,8 +56,8 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         TestClass val2 = oh.get().as<TestClass>();
-        EXPECT_EQ(val1.i, val2.i);
+        BOOST_CHECK_EQUAL(val1.i, val2.i);
-        EXPECT_EQ(val1.s, val2.s);
+        BOOST_CHECK_EQUAL(val1.s, val2.s);
     }
 }
 
@@ -84,7 +74,7 @@ public:
     MSGPACK_DEFINE(i, s, v);
 };
 
-TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
+BOOST_AUTO_TEST_CASE(simple_buffer_class_old_to_new)
 {
     for (unsigned int k = 0; k < kLoop; k++) {
         TestClass val1;
@@ -93,13 +83,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         TestClass2 val2 = oh.get().as<TestClass2>();
-        EXPECT_EQ(val1.i, val2.i);
+        BOOST_CHECK_EQUAL(val1.i, val2.i);
-        EXPECT_EQ(val1.s, val2.s);
+        BOOST_CHECK_EQUAL(val1.s, val2.s);
-        EXPECT_FALSE(val2.s.empty());
+        BOOST_CHECK(!val2.s.empty());
     }
 }
 
-TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
+BOOST_AUTO_TEST_CASE(simple_buffer_class_new_to_old)
 {
     for (unsigned int k = 0; k < kLoop; k++) {
         TestClass2 val1;
@@ -108,13 +98,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         TestClass val2 = oh.get().as<TestClass>();
-        EXPECT_EQ(val1.i, val2.i);
+        BOOST_CHECK_EQUAL(val1.i, val2.i);
-        EXPECT_EQ(val1.s, val2.s);
+        BOOST_CHECK_EQUAL(val1.s, val2.s);
-        EXPECT_FALSE(val2.s.empty());
+        BOOST_CHECK(!val2.s.empty());
     }
 }
 
-TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
+BOOST_AUTO_TEST_CASE(simple_buffer_enum_member)
 {
     TestEnumMemberClass val1;
     msgpack::sbuffer sbuf;
@@ -122,9 +112,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     TestEnumMemberClass val2 = oh.get().as<TestEnumMemberClass>();
-    EXPECT_EQ(val1.t1, val2.t1);
+    BOOST_CHECK_EQUAL(val1.t1, val2.t1);
-    EXPECT_EQ(val1.t2, val2.t2);
+    BOOST_CHECK_EQUAL(val1.t2, val2.t2);
-    EXPECT_EQ(val1.t3, val2.t3);
+    BOOST_CHECK_EQUAL(val1.t3, val2.t3);
 }
 
 class TestUnionMemberClass
@@ -161,21 +151,21 @@ public:
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
-        msgpack::type::tuple<bool, msgpack::object> tuple(false, msgpack::object());
+        msgpack::type::tuple<bool, msgpack::object> tuple;
         o.convert(tuple);
 
         is_double = tuple.get<0>();
         if (is_double)
-            tuple.get<1>().convert(value.f);
+            tuple.get<1>().convert<double>(value.f);
         else
-            tuple.get<1>().convert(value.i);
+            tuple.get<1>().convert<int>(value.i);
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     }
 };
 
-TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
+BOOST_AUTO_TEST_CASE(simple_buffer_union_member)
 {
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
@@ -189,8 +179,8 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         TestUnionMemberClass val2 = oh.get().as<TestUnionMemberClass>();
-        EXPECT_EQ(val1.is_double, val2.is_double);
+        BOOST_CHECK_EQUAL(val1.is_double, val2.is_double);
-        EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
+        BOOST_CHECK(fabs(val1.value.f - val2.value.f) < kEPS);
     }
     {
         // int
@@ -200,9 +190,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         TestUnionMemberClass val2 = oh.get().as<TestUnionMemberClass>();
-        EXPECT_EQ(val1.is_double, val2.is_double);
+        BOOST_CHECK_EQUAL(val1.is_double, val2.is_double);
-        EXPECT_EQ(val1.value.i, 1);
+        BOOST_CHECK_EQUAL(val1.value.i, 1);
-        EXPECT_EQ(val1.value.i, val2.value.i);
+        BOOST_CHECK_EQUAL(val1.value.i, val2.value.i);
     }
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
@@ -233,7 +223,7 @@ struct d_bottom : d_mid1, d_mid2 {
     MSGPACK_DEFINE(MSGPACK_BASE(d_mid1), MSGPACK_BASE(d_mid2), b);
 };
 
-TEST(MSGPACK_INHERIT, define_non_virtual)
+BOOST_AUTO_TEST_CASE(inherit_define_non_virtual)
 {
     d_bottom b;
     b.b = 1;
@@ -246,11 +236,11 @@ TEST(MSGPACK_INHERIT, define_non_virtual)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     d_bottom br = oh.get().as<d_bottom>();
-    EXPECT_EQ(b.b, br.b);
+    BOOST_CHECK_EQUAL(b.b, br.b);
-    EXPECT_EQ(b.m1, br.m1);
+    BOOST_CHECK_EQUAL(b.m1, br.m1);
-    EXPECT_EQ(b.m2, br.m2);
+    BOOST_CHECK_EQUAL(b.m2, br.m2);
-    EXPECT_EQ(b.d_mid1::t, br.d_mid1::t);
+    BOOST_CHECK_EQUAL(b.d_mid1::t, br.d_mid1::t);
-    EXPECT_EQ(b.d_mid2::t, br.d_mid2::t);
+    BOOST_CHECK_EQUAL(b.d_mid2::t, br.d_mid2::t);
 }
 
 struct v_d_top {
@@ -273,7 +263,7 @@ struct v_d_bottom : v_d_mid1, v_d_mid2 {
     MSGPACK_DEFINE(MSGPACK_BASE(v_d_mid1), MSGPACK_BASE(v_d_mid2), MSGPACK_BASE(v_d_top), b);
 };
 
-TEST(MSGPACK_INHERIT, define_virtual)
+BOOST_AUTO_TEST_CASE(inherit_define_virtual)
 {
     v_d_bottom b;
     b.b = 1;
@@ -285,10 +275,10 @@ TEST(MSGPACK_INHERIT, define_virtual)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     v_d_bottom br = oh.get().as<v_d_bottom>();
-    EXPECT_EQ(b.b, br.b);
+    BOOST_CHECK_EQUAL(b.b, br.b);
-    EXPECT_EQ(b.m1, br.m1);
+    BOOST_CHECK_EQUAL(b.m1, br.m1);
-    EXPECT_EQ(b.m2, br.m2);
+    BOOST_CHECK_EQUAL(b.m2, br.m2);
-    EXPECT_EQ(b.t, br.t);
+    BOOST_CHECK_EQUAL(b.t, br.t);
 }
 
 // define_array
@@ -313,7 +303,7 @@ struct da_bottom : da_mid1, da_mid2 {
     MSGPACK_DEFINE_ARRAY(MSGPACK_BASE_ARRAY(da_mid1), MSGPACK_BASE_ARRAY(da_mid2), b);
 };
 
-TEST(MSGPACK_INHERIT, define_array_non_virtual)
+BOOST_AUTO_TEST_CASE(inherit_define_array_non_virtual)
 {
     da_bottom b;
     b.b = 1;
@@ -326,11 +316,11 @@ TEST(MSGPACK_INHERIT, define_array_non_virtual)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     da_bottom br = oh.get().as<da_bottom>();
-    EXPECT_EQ(b.b, br.b);
+    BOOST_CHECK_EQUAL(b.b, br.b);
-    EXPECT_EQ(b.m1, br.m1);
+    BOOST_CHECK_EQUAL(b.m1, br.m1);
-    EXPECT_EQ(b.m2, br.m2);
+    BOOST_CHECK_EQUAL(b.m2, br.m2);
-    EXPECT_EQ(b.da_mid1::t, br.da_mid1::t);
+    BOOST_CHECK_EQUAL(b.da_mid1::t, br.da_mid1::t);
-    EXPECT_EQ(b.da_mid2::t, br.da_mid2::t);
+    BOOST_CHECK_EQUAL(b.da_mid2::t, br.da_mid2::t);
 }
 
 struct v_da_top {
@@ -353,7 +343,7 @@ struct v_da_bottom : v_da_mid1, v_da_mid2 {
     MSGPACK_DEFINE_ARRAY(MSGPACK_BASE_ARRAY(v_da_mid1), MSGPACK_BASE_ARRAY(v_da_mid2), MSGPACK_BASE_ARRAY(v_da_top), b);
 };
 
-TEST(MSGPACK_INHERIT, define_array_virtual)
+BOOST_AUTO_TEST_CASE(inherit_define_array_virtual)
 {
     v_da_bottom b;
     b.b = 1;
@@ -365,10 +355,10 @@ TEST(MSGPACK_INHERIT, define_array_virtual)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     v_da_bottom br = oh.get().as<v_da_bottom>();
-    EXPECT_EQ(b.b, br.b);
+    BOOST_CHECK_EQUAL(b.b, br.b);
-    EXPECT_EQ(b.m1, br.m1);
+    BOOST_CHECK_EQUAL(b.m1, br.m1);
-    EXPECT_EQ(b.m2, br.m2);
+    BOOST_CHECK_EQUAL(b.m2, br.m2);
-    EXPECT_EQ(b.t, br.t);
+    BOOST_CHECK_EQUAL(b.t, br.t);
 }
 
 // define_map
@@ -393,7 +383,7 @@ struct dm_bottom : dm_mid1, dm_mid2 {
     MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(dm_mid1), MSGPACK_BASE_MAP(dm_mid2), b);
 };
 
-TEST(MSGPACK_INHERIT, define_map_non_virtual)
+BOOST_AUTO_TEST_CASE(inherit_define_map_non_virtual)
 {
     dm_bottom b;
     b.b = 1;
@@ -413,11 +403,11 @@ TEST(MSGPACK_INHERIT, define_map_non_virtual)
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
-    EXPECT_EQ(b.b, br.b);
+    BOOST_CHECK_EQUAL(b.b, br.b);
-    EXPECT_EQ(b.m1, br.m1);
+    BOOST_CHECK_EQUAL(b.m1, br.m1);
-    EXPECT_EQ(b.m2, br.m2);
+    BOOST_CHECK_EQUAL(b.m2, br.m2);
-    EXPECT_EQ(b.dm_mid1::t, br.dm_mid1::t);
+    BOOST_CHECK_EQUAL(b.dm_mid1::t, br.dm_mid1::t);
-    EXPECT_EQ(b.dm_mid2::t, br.dm_mid2::t);
+    BOOST_CHECK_EQUAL(b.dm_mid2::t, br.dm_mid2::t);
 }
 
 struct v_dm_top {
@@ -440,7 +430,7 @@ struct v_dm_bottom : v_dm_mid1, v_dm_mid2 {
     MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(v_dm_mid1), MSGPACK_BASE_MAP(v_dm_mid2), MSGPACK_BASE_MAP(v_dm_top), b);
 };
 
-TEST(MSGPACK_INHERIT, define_map_virtual)
+BOOST_AUTO_TEST_CASE(inherit_define_map_virtual)
 {
     v_dm_bottom b;
     b.b = 1;
@@ -452,10 +442,10 @@ TEST(MSGPACK_INHERIT, define_map_virtual)
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
     v_dm_bottom br = oh.get().as<v_dm_bottom>();
-    EXPECT_EQ(b.b, br.b);
+    BOOST_CHECK_EQUAL(b.b, br.b);
-    EXPECT_EQ(b.m1, br.m1);
+    BOOST_CHECK_EQUAL(b.m1, br.m1);
-    EXPECT_EQ(b.m2, br.m2);
+    BOOST_CHECK_EQUAL(b.m2, br.m2);
-    EXPECT_EQ(b.t, br.t);
+    BOOST_CHECK_EQUAL(b.t, br.t);
 }
 
 // map migration
@@ -475,7 +465,7 @@ struct s_v2 {
     MSGPACK_DEFINE_MAP(c, s, i); // variable added, order changed
 };
 
-TEST(MSGPACK_MIGRATION, order_number_changed)
+BOOST_AUTO_TEST_CASE(migration_order_number_changed)
 {
     s_v1 v1;
     msgpack::sbuffer sbuf;
@@ -485,9 +475,9 @@ TEST(MSGPACK_MIGRATION, order_number_changed)
         msgpack::unpack(sbuf.data(), sbuf.size());
     s_v2 v2 = oh.get().as<s_v2>();
 
-    EXPECT_EQ(v2.c, 'A');
+    BOOST_CHECK_EQUAL(v2.c, 'A');
-    EXPECT_EQ(v2.s, "foo"); // from v1
+    BOOST_CHECK_EQUAL(v2.s, "foo"); // from v1
-    EXPECT_EQ(v2.i, 42);    // from v1
+    BOOST_CHECK_EQUAL(v2.i, 42);    // from v1
 }
 
 // non intrusive with operator <<
@@ -541,7 +531,7 @@ struct object_with_zone<test_non_intrusive>
 } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
 } // namespace msgpack
 
-TEST(MSGPACK_USER_DEFINED, test_non_intrusive)
+BOOST_AUTO_TEST_CASE(test_non_intrusive_)
 {
     test_non_intrusive t1;
     msgpack::sbuffer sbuf;
@@ -551,7 +541,7 @@ TEST(MSGPACK_USER_DEFINED, test_non_intrusive)
         msgpack::unpack(sbuf.data(), sbuf.size());
     test_non_intrusive t2 = oh.get().as<test_non_intrusive>();
 
-    EXPECT_EQ(t1.name(), t2.name());
+    BOOST_CHECK_EQUAL(t1.name(), t2.name());
 }
 
 struct nvp_base {
@@ -566,7 +556,7 @@ struct nvp_derived : nvp_base {
     MSGPACK_DEFINE_MAP(MSGPACK_NVP("ccc", c), MSGPACK_NVP("base", MSGPACK_BASE(nvp_base)), MSGPACK_NVP("ddd", d));
 };
 
-TEST(MSGPACK_NVP, combination)
+BOOST_AUTO_TEST_CASE(nvp_combination)
 {
     msgpack::sbuffer sbuf;
     nvp_derived d1;
@@ -579,36 +569,36 @@ TEST(MSGPACK_NVP, combination)
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
     msgpack::object obj = oh.get();
 
-    EXPECT_EQ(obj.via.map.size, static_cast<size_t>(3));
+    BOOST_CHECK_EQUAL(obj.via.map.size, static_cast<size_t>(3));
 
-    EXPECT_EQ(std::string(obj.via.map.ptr[0].key.via.str.ptr, obj.via.map.ptr[0].key.via.str.size), "ccc");
+    BOOST_CHECK_EQUAL(std::string(obj.via.map.ptr[0].key.via.str.ptr, obj.via.map.ptr[0].key.via.str.size), "ccc");
-    EXPECT_EQ(obj.via.map.ptr[0].val.via.i64, 3);
+    BOOST_CHECK_EQUAL(obj.via.map.ptr[0].val.via.i64, 3);
 
-    EXPECT_EQ(std::string(obj.via.map.ptr[1].key.via.str.ptr, obj.via.map.ptr[1].key.via.str.size), "base");
+    BOOST_CHECK_EQUAL(std::string(obj.via.map.ptr[1].key.via.str.ptr, obj.via.map.ptr[1].key.via.str.size), "base");
-    EXPECT_EQ(obj.via.map.ptr[1].val.via.map.size, static_cast<size_t>(2));
+    BOOST_CHECK_EQUAL(obj.via.map.ptr[1].val.via.map.size, static_cast<size_t>(2));
-    EXPECT_EQ(
+    BOOST_CHECK_EQUAL(
         std::string(
             obj.via.map.ptr[1].val.via.map.ptr[0].key.via.str.ptr,
             obj.via.map.ptr[1].val.via.map.ptr[0].key.via.str.size),
         "aaa"
     );
-    EXPECT_EQ(obj.via.map.ptr[1].val.via.map.ptr[0].val.via.i64, 1);
+    BOOST_CHECK_EQUAL(obj.via.map.ptr[1].val.via.map.ptr[0].val.via.i64, 1);
-    EXPECT_EQ(
+    BOOST_CHECK_EQUAL(
         std::string(
             obj.via.map.ptr[1].val.via.map.ptr[1].key.via.str.ptr,
             obj.via.map.ptr[1].val.via.map.ptr[1].key.via.str.size),
         "b"
     );
-    EXPECT_EQ(obj.via.map.ptr[1].val.via.map.ptr[1].val.via.i64, 2);
+    BOOST_CHECK_EQUAL(obj.via.map.ptr[1].val.via.map.ptr[1].val.via.i64, 2);
 
-    EXPECT_EQ(std::string(obj.via.map.ptr[2].key.via.str.ptr, obj.via.map.ptr[2].key.via.str.size), "ddd");
+    BOOST_CHECK_EQUAL(std::string(obj.via.map.ptr[2].key.via.str.ptr, obj.via.map.ptr[2].key.via.str.size), "ddd");
-    EXPECT_EQ(std::string(obj.via.map.ptr[2].val.via.str.ptr, obj.via.map.ptr[2].val.via.str.size), "ABC");
+    BOOST_CHECK_EQUAL(std::string(obj.via.map.ptr[2].val.via.str.ptr, obj.via.map.ptr[2].val.via.str.size), "ABC");
 
     nvp_derived d2 = obj.as<nvp_derived>();
-    EXPECT_EQ(d2.a, 1);
+    BOOST_CHECK_EQUAL(d2.a, 1);
-    EXPECT_EQ(d2.b, 2);
+    BOOST_CHECK_EQUAL(d2.b, 2);
-    EXPECT_EQ(d2.c, 3);
+    BOOST_CHECK_EQUAL(d2.c, 3);
-    EXPECT_EQ(d2.d, "ABC");
+    BOOST_CHECK_EQUAL(d2.d, "ABC");
 }
 
 struct invalid_key {
@@ -616,7 +606,7 @@ struct invalid_key {
     MSGPACK_DEFINE_MAP(val);
 };
 
-TEST(MSGPACK_USER_DEFINED, test_invalid_key_type)
+BOOST_AUTO_TEST_CASE(test_invalid_key_type)
 {
     msgpack::sbuffer sbuf;
     msgpack::packer<msgpack::sbuffer> pk(sbuf);
@@ -626,12 +616,12 @@ TEST(MSGPACK_USER_DEFINED, test_invalid_key_type)
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
     try {
         oh.get().as<invalid_key>();
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     catch (msgpack::type_error const&) {
-        EXPECT_TRUE(true);
+        BOOST_CHECK(true);
     }
     catch (...) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
 }

test/version.cpp

@@ -1,24 +1,18 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE version
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+#include <cstdio>
 
-#if defined(__GNUC__)
+BOOST_AUTO_TEST_CASE(print)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-TEST(version, print)
 {
-    printf("MSGPACK_VERSION            : %s\n", MSGPACK_VERSION);
+    std::printf("MSGPACK_VERSION            : %s\n", MSGPACK_VERSION);
-    printf("MSGPACK_VERSION_MAJOR      : %d\n", MSGPACK_VERSION_MAJOR);
+    std::printf("MSGPACK_VERSION_MAJOR      : %d\n", MSGPACK_VERSION_MAJOR);
-    printf("MSGPACK_VERSION_MINOR      : %d\n", MSGPACK_VERSION_MINOR);
+    std::printf("MSGPACK_VERSION_MINOR      : %d\n", MSGPACK_VERSION_MINOR);
-    printf("MSGPACK_VERSION_REVISION   : %d\n", MSGPACK_VERSION_REVISION);
+    std::printf("MSGPACK_VERSION_REVISION   : %d\n", MSGPACK_VERSION_REVISION);
-    printf("msgpack_version()          : %s\n", msgpack_version());
+    std::printf("msgpack_version()          : %s\n", msgpack_version());
-    printf("msgpack_version_major()    : %d\n", msgpack_version_major());
+    std::printf("msgpack_version_major()    : %d\n", msgpack_version_major());
-    printf("msgpack_version_minor()    : %d\n", msgpack_version_minor());
+    std::printf("msgpack_version_minor()    : %d\n", msgpack_version_minor());
-    printf("msgpack_version_revision() : %d\n", msgpack_version_revision());
+    std::printf("msgpack_version_revision() : %d\n", msgpack_version_revision());
 }

test/visitor.cpp

@@ -1,20 +1,11 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE visitor
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
-
-#include <gtest/gtest.h>
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
 
 #include <sstream>
 
-// To avoid link error
+BOOST_AUTO_TEST_CASE(dummy)
-TEST(visitor, dummy)
 {
 }
 
@@ -80,15 +71,15 @@ struct json_like_visitor : msgpack::null_visitor {
         return true;
     }
     void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
-        EXPECT_TRUE(false);
+        BOOST_CHECK(false);
     }
     std::string& m_s;
 };
 
-TEST(visitor, json_like)
+BOOST_AUTO_TEST_CASE(json_like)
 {
     std::stringstream ss;
     msgpack::packer<std::stringstream> p(ss);
@@ -104,58 +95,58 @@ TEST(visitor, json_like)
     std::size_t off = 0;
     std::string const& str = ss.str();
     bool ret = msgpack::parse(str.data(), str.size(), off, v);
-    EXPECT_TRUE(ret);
+    BOOST_CHECK(ret);
-    EXPECT_EQ("{\"key\":[42,null,true]}", json_like);
+    BOOST_CHECK_EQUAL("{\"key\":[42,null,true]}", json_like);
 }
 
 struct parse_error_check_visitor : msgpack::null_visitor {
     parse_error_check_visitor(bool& called):m_called(called) {}
     void parse_error(size_t parsed_offset, size_t error_offset) {
-        EXPECT_EQ(static_cast<size_t>(1), parsed_offset);
+        BOOST_CHECK_EQUAL(static_cast<size_t>(1), parsed_offset);
-        EXPECT_EQ(static_cast<size_t>(2), error_offset);
+        BOOST_CHECK_EQUAL(static_cast<size_t>(2), error_offset);
         m_called = true;
     }
     bool& m_called;
 };
 
-TEST(visitor, parse_error)
+BOOST_AUTO_TEST_CASE(parse_error)
 {
     bool called = false;
     parse_error_check_visitor v(called);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, static_cast<char>(0xc1u), 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_TRUE(called);
+    BOOST_CHECK(called);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(2u, off);
+    BOOST_CHECK_EQUAL(2u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
 struct insuf_bytes_check_visitor : msgpack::null_visitor {
     insuf_bytes_check_visitor(bool& called):m_called(called) {}
     void insufficient_bytes(size_t parsed_offset, size_t error_offset) {
-        EXPECT_EQ(static_cast<size_t>(2), parsed_offset);
+        BOOST_CHECK_EQUAL(static_cast<size_t>(2), parsed_offset);
-        EXPECT_EQ(static_cast<size_t>(3), error_offset);
+        BOOST_CHECK_EQUAL(static_cast<size_t>(3), error_offset);
         m_called = true;
     }
     bool& m_called;
 };
 
-TEST(visitor, insuf_bytes)
+BOOST_AUTO_TEST_CASE(insuf_bytes)
 {
     bool called = false;
     insuf_bytes_check_visitor v(called);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, 0x01u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_TRUE(called);
+    BOOST_CHECK(called);
     // Even if MSGPACK_DEFAULT_API_VERSION is 2, then off is updated
     // in the case of insufficient bytes.
-    EXPECT_EQ(3u, off);
+    BOOST_CHECK_EQUAL(3u, off);
 }
 
 struct return_false_array_val_visitor : msgpack::null_visitor {
@@ -167,19 +158,19 @@ struct return_false_array_val_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_array_val)
+BOOST_AUTO_TEST_CASE(return_false_array_val)
 {
     std::size_t times = 0;
     return_false_array_val_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(2u, off);
+    BOOST_CHECK_EQUAL(2u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -192,19 +183,19 @@ struct return_false_start_array_item_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_start_array_item)
+BOOST_AUTO_TEST_CASE(return_false_start_array_item)
 {
     std::size_t times = 0;
     return_false_start_array_item_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(2u, off);
+    BOOST_CHECK_EQUAL(2u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -217,19 +208,19 @@ struct return_false_end_array_item_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_end_array_item)
+BOOST_AUTO_TEST_CASE(return_false_end_array_item)
 {
     std::size_t times = 0;
     return_false_end_array_item_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(2u, off);
+    BOOST_CHECK_EQUAL(2u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -239,14 +230,14 @@ struct return_false_start_array_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_start_array)
+BOOST_AUTO_TEST_CASE(return_false_start_array)
 {
     return_false_start_array_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 }
 
 struct return_false_start_array0_visitor : msgpack::null_visitor {
@@ -255,14 +246,14 @@ struct return_false_start_array0_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_start_array0)
+BOOST_AUTO_TEST_CASE(return_false_start_array0)
 {
     return_false_start_array0_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x90u) };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 }
 
 struct return_false_end_array_visitor : msgpack::null_visitor {
@@ -271,17 +262,17 @@ struct return_false_end_array_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_end_array)
+BOOST_AUTO_TEST_CASE(return_false_end_array)
 {
     return_false_end_array_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(3u, off);
+    BOOST_CHECK_EQUAL(3u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -291,14 +282,14 @@ struct return_false_end_array0_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_end_array0)
+BOOST_AUTO_TEST_CASE(return_false_end_array0)
 {
     return_false_end_array0_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x90u) };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 }
 
 struct return_false_map_val_visitor : msgpack::null_visitor {
@@ -310,19 +301,19 @@ struct return_false_map_val_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_map_val)
+BOOST_AUTO_TEST_CASE(return_false_map_val)
 {
     std::size_t times = 0;
     return_false_map_val_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(2u, off);
+    BOOST_CHECK_EQUAL(2u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -335,19 +326,19 @@ struct return_false_start_map_key_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_start_map_key)
+BOOST_AUTO_TEST_CASE(return_false_start_map_key)
 {
     std::size_t times = 0;
     return_false_start_map_key_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(3u, off);
+    BOOST_CHECK_EQUAL(3u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -360,19 +351,19 @@ struct return_false_end_map_key_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_end_map_key)
+BOOST_AUTO_TEST_CASE(return_false_end_map_key)
 {
     std::size_t times = 0;
     return_false_end_map_key_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(3u, off);
+    BOOST_CHECK_EQUAL(3u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -385,19 +376,19 @@ struct return_false_start_map_value_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_start_map_value)
+BOOST_AUTO_TEST_CASE(return_false_start_map_value)
 {
     std::size_t times = 0;
     return_false_start_map_value_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(4u, off);
+    BOOST_CHECK_EQUAL(4u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -410,19 +401,19 @@ struct return_false_end_map_value_visitor : msgpack::null_visitor {
     std::size_t& m_times;
 };
 
-TEST(visitor, return_false_end_map_value)
+BOOST_AUTO_TEST_CASE(return_false_end_map_value)
 {
     std::size_t times = 0;
     return_false_end_map_value_visitor v(times);
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(2u, times);
+    BOOST_CHECK_EQUAL(2u, times);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(4u, off);
+    BOOST_CHECK_EQUAL(4u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -432,14 +423,14 @@ struct return_false_start_map_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_start_map)
+BOOST_AUTO_TEST_CASE(return_false_start_map)
 {
     return_false_start_map_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 }
 
 struct return_false_start_map0_visitor : msgpack::null_visitor {
@@ -448,14 +439,14 @@ struct return_false_start_map0_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_start_map0)
+BOOST_AUTO_TEST_CASE(return_false_start_map0)
 {
     return_false_start_map0_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x80u) };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 }
 
 struct return_false_end_map_visitor : msgpack::null_visitor {
@@ -464,17 +455,17 @@ struct return_false_end_map_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_end_map)
+BOOST_AUTO_TEST_CASE(return_false_end_map)
 {
     return_false_end_map_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
 #if MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 #else  // MSGPACK_DEFAULT_API_VERSION < 3
-    EXPECT_EQ(6u, off);
+    BOOST_CHECK_EQUAL(6u, off);
 #endif // MSGPACK_DEFAULT_API_VERSION < 3
 }
 
@@ -484,14 +475,14 @@ struct return_false_end_map0_visitor : msgpack::null_visitor {
     }
 };
 
-TEST(visitor, return_false_end_map0)
+BOOST_AUTO_TEST_CASE(return_false_end_map0)
 {
     return_false_end_map0_visitor v;
     std::size_t off = 0;
     char const data[] = { static_cast<char>(0x80u) };
     bool ret = msgpack::parse(data, sizeof(data), off, v);
-    EXPECT_FALSE(ret);
+    BOOST_CHECK(!ret);
-    EXPECT_EQ(0u, off);
+    BOOST_CHECK_EQUAL(0u, off);
 }
 
 #endif // MSGPACK_DEFAULT_API_VERSION >= 1

test/zone.cpp

@@ -1,38 +1,30 @@
 #include <msgpack.hpp>
 
-#if defined(__GNUC__)
+#define BOOST_TEST_MODULE zone
-#pragma GCC diagnostic push
+#include <boost/test/unit_test.hpp>
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif //defined(__GNUC__)
 
-#include <gtest/gtest.h>
+BOOST_AUTO_TEST_CASE(allocate_align)
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif //defined(__GNUC__)
-
-TEST(zone, allocate_align)
 {
     msgpack::zone z;
     char* start = (char*)z.allocate_align(1);
-    EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(start) % sizeof(int));
+    BOOST_CHECK_EQUAL(0ul, reinterpret_cast<std::size_t>(start) % sizeof(int));
     for (std::size_t s = 1; s < sizeof(int); ++s) {
         z.allocate_no_align(s);
         char* buf_a = (char*)z.allocate_align(1);
-        EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(buf_a) % sizeof(int));
+        BOOST_CHECK_EQUAL(0ul, reinterpret_cast<std::size_t>(buf_a) % sizeof(int));
     }
 }
 
-TEST(zone, allocate_align_custom)
+BOOST_AUTO_TEST_CASE(allocate_align_custom)
 {
     msgpack::zone z;
     for (std::size_t align = 1; align < 64; ++align) {
         char* start = (char*)z.allocate_align(1, align);
-        EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(start) % align);
+        BOOST_CHECK_EQUAL(0ul, reinterpret_cast<std::size_t>(start) % align);
         for (std::size_t s = 1; s < align; ++s) {
             z.allocate_no_align(s);
             char* buf_a = (char*)z.allocate_align(1, align);
-            EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(buf_a) % align);
+            BOOST_CHECK_EQUAL(0ul, reinterpret_cast<std::size_t>(buf_a) % align);
         }
     }
 }
@@ -54,21 +46,21 @@ private:
 };
 
 
-TEST(zone, allocate)
+BOOST_AUTO_TEST_CASE(allocate)
 {
     msgpack::zone z;
     myclass* m = z.allocate<myclass>();
-    EXPECT_EQ(m->num, 0);
+    BOOST_CHECK_EQUAL(m->num, 0);
-    EXPECT_EQ(m->str, "default");
+    BOOST_CHECK_EQUAL(m->str, "default");
 }
 
 
-TEST(zone, allocate_constructor)
+BOOST_AUTO_TEST_CASE(allocate_constructor)
 {
     msgpack::zone z;
     myclass* m = z.allocate<myclass>(7, "msgpack");
-    EXPECT_EQ(m->num, 7);
+    BOOST_CHECK_EQUAL(m->num, 7);
-    EXPECT_EQ(m->str, "msgpack");
+    BOOST_CHECK_EQUAL(m->str, "msgpack");
 }
 
 
@@ -78,7 +70,7 @@ static void custom_finalizer_func(void* user)
     delete m;
 }
 
-TEST(zone, push_finalizer)
+BOOST_AUTO_TEST_CASE(push_finalizer)
 {
     msgpack::zone z;
     myclass* m = new myclass();
@@ -86,7 +78,7 @@ TEST(zone, push_finalizer)
 }
 
 
-TEST(zone, push_finalizer_unique_ptr)
+BOOST_AUTO_TEST_CASE(push_finalizer_unique_ptr)
 {
     msgpack::zone z;
     msgpack::unique_ptr<myclass> am(new myclass());
@@ -94,10 +86,10 @@ TEST(zone, push_finalizer_unique_ptr)
 }
 
 
-TEST(zone, allocate_no_align)
+BOOST_AUTO_TEST_CASE(allocate_no_align)
 {
     msgpack::zone z;
-    char* buf1 = (char*)z.allocate_no_align(4);
+    char* buf1 = reinterpret_cast<char*>(z.allocate_no_align(4));
-    char* buf2 = (char*)z.allocate_no_align(4);
+    char* buf2 = reinterpret_cast<char*>(z.allocate_no_align(4));
-    EXPECT_EQ(buf1+4, buf2);
+    BOOST_CHECK_EQUAL(reinterpret_cast<void*>(buf1+4), reinterpret_cast<void*>(buf2));
 }