generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-06-26 06:25:22 +02:00
Code Issues Projects Releases Wiki Activity

Merge pull request #951 from kovdan01/add_span_support

Browse Source 
Modernize codebase
This commit is contained in:
Takatoshi Kondo 2021-08-29 11:10:37 +09:00 committed by GitHub
commit 76f5af0593
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
86 changed files with 4156 additions and 3825 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
.github/depends/boost.sh vendored
View File

@ -1,23 +1,35 @@
#!/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`/..
./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 \
--toolset=$1 \
--prefix=$3/$2 \
--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 +39,28 @@ 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
tar xf boost_1_72_0.tar.bz2
cd boost_1_72_0
./bootstrap.sh
mkdir $prefix || exit 1
wget https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.bz2 || exit 1
tar xf boost_1_76_0.tar.bz2 || exit 1
cd boost_1_76_0
./bootstrap.sh || exit 1
build()
{
if [ "$bit" = "both" ]; then
build_boost $1 32
build_boost $1 64
build_boost $1 32 $prefix
build_boost $1 64 $prefix
else
build_boost $1 $bit
build_boost $1 $bit $prefix
fi
}

51
.github/depends/zlib.sh vendored Executable file
View File

@ -0,0 +1,51 @@
#!/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" ] && [ "$bit" != "both" ] && usage && exit 1
;;
p)
prefix="$OPTARG"
;;
?*)
echo "invalid arguments." && exit 1
;;
esac
done
mkdir $prefix || exit 1
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
build()
{
cmake \
-D CMAKE_BUILD_TYPE=Release \
-D CMAKE_INSTALL_PREFIX=$2/$1 \
-D CMAKE_C_FLAGS="-m$1" \
-D CMAKE_SHARED_LINKER_FLAGS="-m$1" \
-B build$1 \
-S .
cmake --build build$1 --target install
}
if [ "$bit" = "both" ]; then
build 32 $prefix
build 64 $prefix
else
build $bit $prefix
fi

59
.github/workflows/coverage.yml vendored
View File

@ -10,47 +10,58 @@ on:
- '*'
jobs:
codecov:
timeout-minutes: 30
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v1
- name: install depends
- name: Install build dependencies
run: |
sudo apt-get update
sudo apt-get install g++-multilib lcov
sudo apt-get install g++-10 cmake lcov -y
./ci/set_gcc_10.sh
- name: Cache boost
id: cache-boost
uses: actions/cache@v1
with:
path: usr
key: ${{ runner.os }}-boost-20210508-1-72-0
path: ~/boost-prefix/
key: ${{ runner.os }}-boost-64-1-76-0-2021-08-09
- 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-2021-08-09
- 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
BASE=`pwd`
wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
unzip -q googletest-release-1.7.0.zip
cd googletest-release-1.7.0
g++ -m64 src/gtest-all.cc -I. -Iinclude -c -fPIC
g++ -m64 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 ..
mkdir build
cmake \
-D MSGPACK_CXX20=ON \
-D MSGPACK_32BIT=OFF \
-D MSGPACK_CHAR_SIGN=signed \
-D MSGPACK_USE_X3_PARSE=ON \
-D MSGPACK_BUILD_EXAMPLES=ON \
-D MSGPACK_BUILD_TESTS=ON \
-D CMAKE_BUILD_TYPE=Debug \
-D MSGPACK_GEN_COVERAGE=ON \
-D CMAKE_PREFIX_PATH="$HOME/zlib-prefix/64;$HOME/boost-prefix/64" \
-B build \
-S . || exit 1
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: |

390
.github/workflows/gha.yml vendored
View File

@ -11,268 +11,226 @@ on:
jobs:
macos:
name: ${{ format('macOS (pattern {0})', matrix.pattern) }}
runs-on: macos-latest
strategy:
fail-fast: false
matrix:
pattern: [0, 1, 2, 3]
pattern: [0, 1, 2, 3, 4]
steps:
- uses: actions/checkout@v1
- uses: actions/checkout@v2
- name: Cache boost
id: cache-boost
uses: actions/cache@v1
uses: actions/cache@v2
with:
path: usr
key: ${{ runner.os }}-boost-20210508-1-72-0
path: ~/boost-prefix/
key: ${{ runner.os }}-boost-1-76-0-2021-08-09
- name: Build boost
if: steps.cache-boost.outputs.cache-hit != 'true'
run: ./.github/depends/boost.sh -b 64 -t clang
- name: build and test
env:
CXX: clang++
run: ./.github/depends/boost.sh -b 64 -t clang -p $HOME/boost-prefix
- name: Cache zlib
id: cache-zlib
uses: actions/cache@v2
with:
path: ~/zlib-prefix/
key: ${{ runner.os }}-zlib-1-2-11-2021-08-09
- name: Build zlib
if: steps.cache-zlib.outputs.cache-hit != 'true'
run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
- name: Build and test
shell: bash
run: |
BASE=`pwd`;
# default configuration - overwrite its params later depending on matrix.pattern
export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
export ARCH=64
export API_VERSION=3
export CHAR_SIGN="signed"
export X3_PARSE="OFF"
export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
# matrix config
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
wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
unzip -q googletest-release-1.7.0.zip
cd googletest-release-1.7.0
$CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c
$CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c
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 ..
case ${{ matrix.pattern }} in
0)
export MSGPACK_CXX_VERSION="MSGPACK_CXX11=OFF"
;;
1)
export API_VERSION=1
;;
2)
export API_VERSION=2
;;
3)
export X3_PARSE="ON"
;;
4)
export CHAR_SIGN="unsigned"
;;
esac
# 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 || exit 1
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 (pattern {0})', matrix.pattern) }}
runs-on: ubuntu-20.04
strategy:
fail-fast: false
matrix:
pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
steps:
- uses: actions/checkout@v1
- name: install build depends
run: |
sudo apt-get update
sudo apt-get install g++-multilib clang-8 valgrind
- name: Cache boost
id: cache-boost
uses: actions/cache@v1
with:
path: usr
key: ${{ runner.os }}-boost-20210508-1-72-0
- name: Build boost
if: steps.cache-boost.outputs.cache-hit != 'true'
run: ./.github/depends/boost.sh -b both -t gcc
- name: build and test
- uses: actions/checkout@v2
- name: Install build dependencies
shell: bash
run: |
BASE=`pwd`;
sudo apt-get update
sudo apt-get install g++-10 cmake valgrind -y
sudo apt-get install g++-10-multilib -y # for 32-bit compile
./ci/set_gcc_10.sh
# matrix config
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
- name: Cache boost
id: cache-boost
uses: actions/cache@v2
with:
path: ~/boost-prefix/
key: ${{ runner.os }}-boost-1-76-0-2021-08-09
# install gtest
wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
unzip -q googletest-release-1.7.0.zip
cd googletest-release-1.7.0
$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 ..
- name: Build boost
if: steps.cache-boost.outputs.cache-hit != 'true'
run: ./.github/depends/boost.sh -b both -t gcc -p $HOME/boost-prefix
# install zlib
if [ ${ARCH} == 32 ]; then
sudo apt-get install lib32z1-dev
fi
- name: Cache zlib
id: cache-zlib
uses: actions/cache@v2
with:
path: ~/zlib-prefix/
key: ${{ runner.os }}-zlib-1-2-11-2021-08-09
- name: Build zlib
if: steps.cache-zlib.outputs.cache-hit != 'true'
run: ./.github/depends/zlib.sh -b both -p $HOME/zlib-prefix
- name: Build and test
shell: bash
run: |
# default configuration - overwrite its params later depending on matrix.pattern
export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
export ARCH=64
export API_VERSION=3
export CHAR_SIGN="signed"
export X3_PARSE="OFF"
export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
export ACTION="ci/build_cmake.sh"
case ${{ matrix.pattern }} in
0)
export CXX="clang++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX11=OFF"
;;
1)
export CXX="g++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
;;
2)
export CXX="clang++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX14=ON"
;;
3)
export CXX="g++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX17=ON"
;;
4)
export CXX="clang++-10"
export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
;;
5)
export CXX="g++-10"
export ARCH=32
;;
6)
export CXX="clang++-10"
export API_VERSION=2
;;
7)
export CXX="g++-10"
export API_VERSION=1
;;
8)
export CXX="clang++-10"
export CHAR_SIGN="unsigned"
;;
9)
export CXX="g++-10"
export X3_PARSE="ON"
;;
10)
export CXX="clang++-10"
export ACTION="ci/build_regression.sh"
;;
11)
export CXX="g++-10"
export ARCH=32
export CHAR_SIGN="unsigned"
export X3_PARSE="ON"
;;
esac
# 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}
CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh || exit 1
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
- uses: actions/checkout@v2
- name: Cache vcpkg dependencies
id: cache-vcpkg
uses: actions/cache@v1.0.3
uses: actions/cache@v2
with:
path: C:/vcpkg/installed/x64-windows
key: ${{ runner.os }}-vcpkg
- name: Build dependencies
key: ${{ runner.os }}-vcpkg-2021-08-09
- name: Install vcpkg 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="-DMSGPACK_CXX17=ON"
}
if (${{ matrix.pattern }} -eq 1) {
$CPPVER="-DMSGPACK_CXX11=ON"
}
if (${{ matrix.pattern }} -eq 2) {
$CPPVER="-DMSGPACK_CXX11=OFF"
}
$CPPVER="MSGPACK_CXX${{ matrix.cxx }}=ON"
$CUR=(Get-Location).Path
md build
cd build
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" ..
if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
cmake --build . --config Release
$pathbak="$env:PATH"
$env:PATH="C:\vcpkg\installed\x64-windows\bin;$CUR\build\Release;$pathbak"
ctest -V
if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
$env:PATH=$pathbak
cmake `
-A x64 `
-G "Visual Studio 16 2019" `
-D CMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" `
-D MSGPACK_BUILD_TESTS=ON `
-D $CPPVER `
-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" `
-B build `
-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 }

214
CMakeLists.txt
View File

@ -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_VERSION VERSION_EQUAL 3.1))
CMAKE_POLICY(SET CMP0054 NEW)
ENDIF ()
CMAKE_POLICY (SET CMP0054 NEW)
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,102 +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_32BIT "32bit compile" OFF)
OPTION (MSGPACK_CXX14 "Using c++14 compiler" OFF)
OPTION (MSGPACK_CXX17 "Using c++17 compiler" OFF)
OPTION (MSGPACK_CXX20 "Using c++20 compiler" 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")
SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
# matches Clang and AppleClang
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
MESSAGE ( FATAL_ERROR "MSVC doesn't support C++14.")
ENDIF ()
ENDIF ()
IF (NOT (MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20))
MESSAGE (FATAL_ERROR "MSGPACK_USE_X3_PARSE requires MSGPACK_CXX14 or newer")
ENDIF ()
SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
ENDIF ()
IF (MSGPACK_CXX20)
SET (CMAKE_CXX_STANDARD 20)
ELSEIF (MSGPACK_CXX17)
SET (CMAKE_CXX_STANDARD 17)
ELSEIF (MSGPACK_CXX14)
SET (CMAKE_CXX_STANDARD 14)
ELSEIF (MSGPACK_CXX11)
SET (CMAKE_CXX_STANDARD 11)
ELSE ()
IF (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 ()
SET (CMAKE_CXX_STANDARD 98)
ENDIF ()
IF (MSGPACK_32BIT)
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
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)
@ -133,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
IF ("${MSGPACK_FUZZ_REGRESSION}" STREQUAL "ON" AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
enable_testing ()
ADD_SUBDIRECTORY (fuzz)
SET (MSGPACK_BUILD_EXAMPLES OFF)
ENDIF ()
TARGET_LINK_LIBRARIES (msgpackc-cxx INTERFACE Boost::boost)
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)
@ -171,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)
INCLUDE(Dart)
FIND_PROGRAM (CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
INCLUDE (Dart)
ADD_SUBDIRECTORY (test)
ENDIF ()
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}")
ELSE ()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
ENDIF ()
# enable regression testing
IF (MSGPACK_FUZZ_REGRESSION)
ENABLE_TESTING ()
ADD_SUBDIRECTORY (fuzz)
ENDIF ()
IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
@ -192,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)
@ -221,3 +166,56 @@ 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/
DESTINATION include
COMPONENT msgpackc-cxx
)
INCLUDE (CMakePackageConfigHelpers)
IF (NOT (CMAKE_VERSION VERSION_LESS 3.14))
SET (extra_version_file_args ARCH_INDEPENDENT)
ENDIF ()
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
)

5
Files.cmake
View File

@ -28,11 +28,13 @@ SET (msgpackc_HEADERS
include/msgpack/adaptor/cpp11/unique_ptr.hpp
include/msgpack/adaptor/cpp11/unordered_map.hpp
include/msgpack/adaptor/cpp11/unordered_set.hpp
include/msgpack/adaptor/cpp17/array_byte.hpp
include/msgpack/adaptor/cpp17/byte.hpp
include/msgpack/adaptor/cpp17/carray_byte.hpp
include/msgpack/adaptor/cpp17/optional.hpp
include/msgpack/adaptor/cpp17/string_view.hpp
include/msgpack/adaptor/cpp17/vector_byte.hpp
include/msgpack/adaptor/cpp20/span.hpp
include/msgpack/adaptor/define.hpp
include/msgpack/adaptor/define_decl.hpp
include/msgpack/adaptor/deque.hpp
@ -68,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
@ -124,11 +127,13 @@ SET (msgpackc_HEADERS
include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp
include/msgpack/v1/adaptor/cpp11/unordered_map.hpp
include/msgpack/v1/adaptor/cpp11/unordered_set.hpp
include/msgpack/v1/adaptor/cpp17/array_byte.hpp
include/msgpack/v1/adaptor/cpp17/byte.hpp
include/msgpack/v1/adaptor/cpp17/carray_byte.hpp
include/msgpack/v1/adaptor/cpp17/optional.hpp
include/msgpack/v1/adaptor/cpp17/string_view.hpp
include/msgpack/v1/adaptor/cpp17/vector_byte.hpp
include/msgpack/v1/adaptor/cpp20/span.hpp
include/msgpack/v1/adaptor/define.hpp
include/msgpack/v1/adaptor/define_decl.hpp
include/msgpack/v1/adaptor/deque.hpp

113
README.md
View File

@ -64,72 +64,112 @@ int main()
See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
Dependency
-----
----------
msgpack-c requires [boost library](https://www.boost.org/).
msgpack-c depends on only boost headers. You don't need to link boost libraries.
C++ version of msgpack-c itself is a header-only library and depends only on
boost headers. Tests depend on boost unit test framework and are linked with
it, so if you want to build them, you need to have this dependency installed.
Usage
-----
### C++ Header Only Library
- If you build your project with cmake, you can find msgpack-c with a
canonical cmake-way:
When you use msgpack on C++, you can just add
msgpack-c/include to your include path:
```cmake
# ...
find_package(msgpack REQUIRED)
# ...
target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE> msgpackc-cxx)
# ...
```
g++ -I msgpack-c/include -I path_to_boost your_source_file.cpp
This will search for `msgpack` cmake package in a system prefix and in
prefixes from `CMAKE_PREFIX_PATH`. Note that msgpack-c depends on boost
headers, and `msgpack` cmake package depends on `Boost` cmake package. The
library is header-only and `target_link_libraries` command just adds path
to msgpack-c headers to your compiler's include path.
A usage example can be found at [test-install](test-install) directory.
### Building and Installing
- If you do not use cmake, you can just add path yo msgpack-c and boost
headers to your include path:
#### Install from git repository
```bash
g++ -I msgpack-c/include -I path_to_boost your_source_file.cpp
```
##### Using the Terminal (CLI)
Building and Installing
-----------------------
### Install from git repository
#### Using the Terminal (CLI)
You will need:
- `gcc >= 4.1.0`
- `cmake >= 3.0.0`
- `gcc >= 4.1.0`
- `cmake >= 3.1.0`
C++03:
$ git clone https://github.com/msgpack/msgpack-c.git
$ cd msgpack-c
$ git checkout cpp_master
$ cmake .
$ make
$ sudo make install
```bash
git clone https://github.com/msgpack/msgpack-c.git
cd msgpack-c
git checkout cpp_master
cmake .
sudo cmake --build . --target install
```
If you want to setup C++17 version of msgpack instead,
execute the following commands:
If you want to build tests with different C++ version, you can use
`MSGPACK_CXX11`, `MSGPACK_CXX14`, `MSGPACK_CXX17`, `MSGPACK_CXX20` options.
Just replace the line
$ git clone https://github.com/msgpack/msgpack-c.git
$ cd msgpack-c
$ git checkout cpp_master
$ cmake -DMSGPACK_CXX17=ON .
$ make
$ sudo make install
```bash
cmake .
```
For C++11, replace `-DMSGPACK_CXX17=ON` with `-DMSGPACK_CXX11=ON`.
with a line like that:
`MSGPACK_CXX11` and `MSGPACK_CXX17` flags do not affect installation. They just switch test cases. All files are installed in every settings.
```bash
cmake -DMSGPACK_CXX20=ON .
```
Note that these flags do not affect installation. They just switch test cases.
All files are installed in every settings.
If you don't have superuser permissions or don't want to install the library
to a system-wide prefix, you can use `CMAKE_INSTALL_PREFIX` option like that:
```bash
cmake -DCMAKE_INSTALL_PREFIX=/your/custom/prefix .
```
Other useful options:
- `MSGPACK_BUILD_TESTS` (default `OFF`): build tests
- `MSGPACK_BUILD_EXAMPLES` (default `OFF`): build examples
- `MSGPACK_32BIT` (default `OFF`): 32bit compile
- `MSGPACK_USE_X3_PARSE` (default `OFF`): use Boost X3 parse
(note that it requires C++14 or newer)
#### GUI on Windows
Clone msgpack-c git repository.
Clone msgpack-c git repository with the command:
$ git clone https://github.com/msgpack/msgpack-c.git
```
git clone https://github.com/msgpack/msgpack-c.git
```
or using GUI git client.
or using GUI git client (e.g. [tortoise git](https://code.google.com/p/tortoisegit/)).
e.g.) tortoise git https://code.google.com/p/tortoisegit/
1. Checkout to cpp_master branch
1. Checkout to `cpp_master` branch
2. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
3. Set 'Where is the source code:' text box and 'Where to build
the binaries:' text box.
3. Set 'Where is the source code:' text box and
'Where to build the binaries:' text box.
4. Click 'Configure' button.
@ -141,7 +181,8 @@ the binaries:' text box.
8. Build all.
### Documentation
Documentation
-------------
You can get additional information including the tutorial on the
[wiki](https://github.com/msgpack/msgpack-c/wiki).

82
appveyor.yml
View File

@ -4,57 +4,63 @@ branches:
only:
- cpp_master
image:
- Visual Studio 2015
environment:
global:
BOOST_ROOT: C:\Libraries\boost_1_67_0
matrix:
- cpp11: -DMSGPACK_CXX11=OFF
example: -DMSGPACK_BUILD_EXAMPLES=OFF
msvc: '"Visual Studio 10 2010"'
- cpp11: -DMSGPACK_CXX11=OFF
example: -DMSGPACK_BUILD_EXAMPLES=OFF
msvc: '"Visual Studio 11 2012"'
- cpp11: -DMSGPACK_CXX11=OFF
example: -DMSGPACK_BUILD_EXAMPLES=OFF
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
cpp11: -DMSGPACK_CXX11=OFF
msvc: '"Visual Studio 12 2013"'
- cpp11: -DMSGPACK_CXX11=ON
example: -DMSGPACK_BUILD_EXAMPLES=ON
boost_prefix: C:\Libraries\boost_1_58_0
boost_subdir: lib32-msvc-12.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
cpp11: -DMSGPACK_CXX11=OFF
msvc: '"Visual Studio 14 2015"'
- cpp11: -DMSGPACK_CXX11=OFF
example: -DMSGPACK_BUILD_EXAMPLES=ON
boost_prefix: C:\Libraries\boost_1_69_0
boost_subdir: lib32-msvc-14.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
cpp11: -DMSGPACK_CXX11=ON
msvc: '"Visual Studio 14 2015"'
boost_prefix: C:\Libraries\boost_1_69_0
boost_subdir: lib32-msvc-14.0
build_script:
- ps: |
appveyor DownloadFile https://github.com/google/googletest/archive/release-1.7.0.zip -FileName googletest-release-1.7.0.zip
7z x googletest-release-1.7.0.zip 2> $null
cd googletest-release-1.7.0
md build
cd build
cmake -G $env:msvc -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 ..
cmake --build . --config Release
cd ..
cd ..
appveyor DownloadFile http://zlib.net/zlib-1.2.11.tar.gz -FileName zlib-1.2.11.tar.gz
7z x zlib-1.2.11.tar.gz 2> $null
7z x zlib-1.2.11.tar 2> $null
cd zlib-1.2.11
md build
md prefix
cd build
cmake -G $env:msvc ..
cmake `
-G $env:msvc `
-D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\zlib-1.2.11\prefix" `
..
if ($LastExitCode -ne 0) { exit $LastExitCode }
cmake --build . --target install --config Release
if ($LastExitCode -ne 0) { exit $LastExitCode }
cd ..\..
md build
md prefix
cd build
cmake `
-G $env:msvc `
$env:cpp11 `
-D MSGPACK_BUILD_EXAMPLES=ON `
-D MSGPACK_BUILD_TESTS=ON `
-D CMAKE_EXE_LINKER_FLAGS=/LIBPATH:"$env:boost_prefix\$env:boost_subdir" `
-D CMAKE_PREFIX_PATH="$env:boost_prefix;$env:APPVEYOR_BUILD_FOLDER\zlib-1.2.11\prefix" `
-D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\prefix" `
-D CMAKE_CXX_FLAGS="/D_VARIADIC_MAX=10 /EHsc /DBOOST_ALL_DYN_LINK" `
..
if ($LastExitCode -ne 0) { exit $LastExitCode }
cmake --build . --config Release
copy zconf.h ..
cd ..
cd ..
if ($env:msvc -ne '"Visual Studio 14 2015"') {
((Get-Content CMakeLists.txt) -replace "COMPONENTS chrono system OPTIONAL_COMPONENTS timer", "") | Set-Content -Path CMakeLists.txt
}
md build
cd build
cmake -G $env:msvc $env:cpp11 $env:example $env:x3_parse -DGTEST_LIBRARY="$env:APPVEYOR_BUILD_FOLDER\googletest-release-1.7.0\build\Release\gtest.lib" -DGTEST_MAIN_LIBRARY="$env:APPVEYOR_BUILD_FOLDER\googletest-release-1.7.0\build\Release\gtest_main.lib" -DGTEST_INCLUDE_DIR="$env:APPVEYOR_BUILD_FOLDER\googletest-release-1.7.0\include" -DZLIB_LIBRARY="$env:APPVEYOR_BUILD_FOLDER\zlib-1.2.11\build\Release\zlib.lib" -DZLIB_INCLUDE_DIR="$env:APPVEYOR_BUILD_FOLDER\zlib-1.2.11" -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
cmake --build . --config Release -v
if ($LastExitCode -ne 0) { exit $LastExitCode }
test_script:
- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
- ctest -V
- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release;%boost_prefix%\%boost_subdir%
- ctest -VV -C Release

113
ci/build_cmake.sh
View File

@ -1,66 +1,37 @@
#!/bin/bash
mkdir build
build_dir="$CXX-build"
prefix_dir="`pwd`/$CXX-prefix"
mkdir $build_dir || exit 1
mkdir $prefix_dir || 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
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/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
-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=$prefix_dir \
-B $build_dir \
-S . || exit 1
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
cmake --build $build_dir --target install || exit 1
make
ctest -VV --test-dir $build_dir || 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
if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]; then
ctest -T memcheck --test-dir $build_dir | tee memcheck.log
ret=${PIPESTATUS[0]}
if [ $ret -ne 0 ]
@ -75,39 +46,15 @@ then
fi
fi
if [ "${ARCH}" != "32" ]
then
mkdir install-test
if [ "${ARCH}" != "32" ]; then
cd test-install || exit 1
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
mkdir $build_dir
cmake \
-D CMAKE_PREFIX_PATH="$prefix_dir;${HOME}/boost-prefix/${ARCH}" \
-B $build_dir \
-S . || exit 1
cmake --build $build_dir --target all || exit 1
cd install-test
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
$build_dir/test-install || exit 1
fi
exit 0

52
ci/build_regression.sh
View File

@ -1,20 +1,7 @@
#!/bin/bash
mkdir -p build
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
cd build
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
build_dir="$CXX-build"
mkdir $build_dir || exit 1
if [ "${ARCH}" == "32" ]
then
@ -22,28 +9,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/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
-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_dir \
-S . || exit 1
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
cmake --build $build_dir --target all || exit 1
make
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
make test
ret=$?
if [ $ret -ne 0 ]
then
exit $ret
fi
exit 0
ctest -VV --test-dir $build_dir || exit 1

17
ci/set_gcc_10.sh Executable file
View File

@ -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}

36
example/boost/CMakeLists.txt
View File

@ -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)
LIST (APPEND exec_PROGRAMS
asio_send_recv.cpp
)
IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
LIST (APPEND exec_PROGRAMS asio_send_recv.cpp)
IF (ZLIB_FOUND)
INCLUDE_DIRECTORIES (
${ZLIB_INCLUDE_DIRS}
)
LIST (APPEND exec_PROGRAMS
asio_send_recv_zlib.cpp
)
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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
)
TARGET_LINK_LIBRARIES (${source_file_we}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpackc-cxx
Boost::system
Threads::Threads
)
IF (ZLIB_FOUND)
TARGET_LINK_LIBRARIES (${source_file_we}
${ZLIB_LIBRARIES}
)
ENDIF()
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE ZLIB::ZLIB)
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 ()

4
example/boost/asio_send_recv_zlib.cpp
View File

@ -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);

36
example/cpp03/CMakeLists.txt
View File

@ -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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpackc-cxx
)
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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
)
TARGET_LINK_LIBRARIES (${source_file_we}
${CMAKE_THREAD_LIBS_INIT}
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpackc-cxx
Threads::Threads
)
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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
)
LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
TARGET_LINK_LIBRARIES (${source_file_we}
${Boost_TIMER_LIBRARY}
${Boost_CHRONO_LIBRARY}
${Boost_SYSTEM_LIBRARY}
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpackc-cxx
Boost::timer
)
IF (NOT MSVC AND NOT APPLE)
TARGET_LINK_LIBRARIES (${source_file_we}
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
rt
)
ENDIF ()

11
example/cpp11/CMakeLists.txt
View File

@ -1,8 +1,4 @@
IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
INCLUDE_DIRECTORIES (
../include
)
IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17)
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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpackc-cxx
)
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")

27
example/x3/CMakeLists.txt
View File

@ -1,9 +1,6 @@
IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
FIND_PACKAGE (Boost REQUIRED COMPONENTS context)
INCLUDE_DIRECTORIES (
../include
)
FIND_PACKAGE (Boost REQUIRED COMPONENTS context system unit_test_framework)
FIND_PACKAGE (Threads REQUIRED)
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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpackc-cxx)
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}
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
)
TARGET_LINK_LIBRARIES (${source_file_we}
${Boost_CONTEXT_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
msgpackc-cxx
Boost::context
Boost::system
Boost::unit_test_framework
Threads::Threads
)
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")

25
fuzz/CMakeLists.txt
View File

@ -1,21 +1,10 @@
FIND_PACKAGE (GTest REQUIRED)
FIND_PACKAGE (ZLIB REQUIRED)
FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem)
INCLUDE_DIRECTORIES (
${GTEST_INCLUDE_DIRS}
${ZLIB_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
)
FIND_PACKAGE (Threads REQUIRED)
FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem unit_test_framework)
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
${GTEST_BOTH_LIBRARIES}
${ZLIB_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT}
${Boost_LIBRARIES}
msgpackc-cxx
Threads::Threads
Boost::filesystem
Boost::system
Boost::unit_test_framework
)
ADD_TEST (${source_file_we} ${source_file_we})
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")

45
fuzz/regression_runner.cpp
View File

@ -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)) {
while (f != boost::filesystem::directory_iterator{}) {
if (boost::filesystem::is_directory(p)) {
while (f != boost::filesystem::directory_iterator()) {
v.push_back((*f++).path().string());
}
}
return v;
}
class UnpackPackFuzzerRegressionTest : public ::testing::TestWithParam<std::string> {
public:
};
TEST_P(UnpackPackFuzzerRegressionTest, Returns0) {
auto fpath = GetParam();
std::ifstream in(fpath, std::ifstream::binary);
void UnpackPackFuzzerRegressionTest(const std::string& fpath) {
std::ifstream in(fpath.c_str(), std::ios_base::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);
EXPECT_EQ(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
bytes.size()));
BOOST_REQUIRE(in);
BOOST_REQUIRE_EQUAL(0, FuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()), bytes.size()));
}
INSTANTIATE_TEST_CASE_P(UnpackPackFuzzerRegressions,
UnpackPackFuzzerRegressionTest,
::testing::ValuesIn(ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions")));
boost::unit_test::test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[])
{
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;
}

6
fuzz/unpack_pack_fuzzer.cpp
View File

@ -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,
nullptr,
MSGPACK_NULLPTR,
MSGPACK_NULLPTR,
msgpack::unpack_limit(test_limit,
test_limit,
test_limit,

16
include/msgpack/adaptor/cpp17/array_byte.hpp Normal file
View File

@ -0,0 +1,16 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 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)
//
#ifndef MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP
#define MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP
#include "msgpack/v1/adaptor/cpp17/array_byte.hpp"
#endif // MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP

16
include/msgpack/adaptor/cpp20/span.hpp Normal file
View File

@ -0,0 +1,16 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 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)
//
#ifndef MSGPACK_TYPE_CPP20_SPAN_HPP
#define MSGPACK_TYPE_CPP20_SPAN_HPP
#include "msgpack/v1/adaptor/cpp20/span.hpp"
#endif // MSGPACK_TYPE_CPP20_SPAN_HPP

18
include/msgpack/cpp_version.hpp Normal file
View File

@ -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

5
include/msgpack/type.hpp
View File

@ -54,10 +54,15 @@
#include "adaptor/cpp17/string_view.hpp"
#endif // MSGPACK_HAS_INCLUDE(<string_view>)
#include "adaptor/cpp17/array_byte.hpp"
#include "adaptor/cpp17/byte.hpp"
#include "adaptor/cpp17/carray_byte.hpp"
#include "adaptor/cpp17/vector_byte.hpp"
#if MSGPACK_HAS_INCLUDE(<span>)
#include "adaptor/cpp20/span.hpp"
#endif // MSGPACK_HAS_INCLUDE(<span>)
#endif // defined(MSGPACK_USE_CPP03)
#include "adaptor/boost/fusion.hpp"

123
include/msgpack/v1/adaptor/cpp17/array_byte.hpp Normal file
View File

@ -0,0 +1,123 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 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)
//
#ifndef MSGPACK_V1_TYPE_ARRAY_BYTE_HPP
#define MSGPACK_V1_TYPE_ARRAY_BYTE_HPP
#include "msgpack/cpp_version.hpp"
#if MSGPACK_CPP_VERSION >= 201703
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <array>
#include <cstring>
#include <cstddef>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <std::size_t N>
struct convert<std::array<std::byte, N> > {
msgpack::object const& operator()(msgpack::object const& o, std::array<std::byte, N>& v) const {
switch (o.type) {
case msgpack::type::BIN:
if (o.via.bin.size != N)
throw msgpack::type_error();
if (N != 0) {
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size);
#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__)
}
break;
case msgpack::type::STR:
if (o.via.bin.size != N)
throw msgpack::type_error();
if (N != 0) {
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size);
#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__)
}
break;
default:
throw msgpack::type_error();
break;
}
return o;
}
};
template <std::size_t N>
struct pack<std::array<std::byte, N> > {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<std::byte, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_bin(size);
if (size != 0) {
o.pack_bin_body(reinterpret_cast<char const*>(&v.front()), size);
}
return o;
}
};
template <std::size_t N>
struct object<std::array<std::byte, N> > {
void operator()(msgpack::object& o, const std::array<std::byte, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
if (size != 0) {
o.via.bin.ptr = reinterpret_cast<char const*>(&v.front());
}
o.via.bin.size = size;
}
};
template <std::size_t N>
struct object_with_zone<std::array<std::byte, N> > {
void operator()(msgpack::object::with_zone& o, const std::array<std::byte, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
o.via.bin.size = size;
if (size != 0) {
char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
o.via.bin.ptr = ptr;
std::memcpy(ptr, &v.front(), size);
}
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_CPP_VERSION >= 201703
#endif // MSGPACK_V1_TYPE_ARRAY_BYTE_HPP

6
include/msgpack/v1/adaptor/cpp17/byte.hpp
View File

@ -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

6
include/msgpack/v1/adaptor/cpp17/carray_byte.hpp
View File

@ -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

6
include/msgpack/v1/adaptor/cpp17/optional.hpp
View File

@ -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

6
include/msgpack/v1/adaptor/cpp17/string_view.hpp
View File

@ -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

6
include/msgpack/v1/adaptor/cpp17/vector_byte.hpp
View File

@ -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

123
include/msgpack/v1/adaptor/cpp20/span.hpp Normal file
View File

@ -0,0 +1,123 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 KONDO Takatoshi and Daniil Kovalev
//
// 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)
//
#ifndef MSGPACK_V1_TYPE_CPP20_SPAN_HPP
#define MSGPACK_V1_TYPE_CPP20_SPAN_HPP
#include "msgpack/cpp_version.hpp"
// 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"
#include "msgpack/adaptor/check_container_size.hpp"
#include "msgpack/meta.hpp"
#include <span>
#include <cstring>
#include <cstddef>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
#define MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY(byte_t) \
template <> \
struct convert<std::span<const byte_t> > { \
msgpack::object const& operator()(msgpack::object const& o, std::span<const byte_t>& v) const { \
switch (o.type) { \
case msgpack::type::BIN: \
v = std::span(reinterpret_cast<const byte_t*>(o.via.bin.ptr), o.via.bin.size); \
break; \
default: \
throw msgpack::type_error(); \
break; \
} \
return o; \
} \
};
#define MSGPACK_ADAPTOR_PACK_SPAN_BINARY(byte_t) \
template <> \
struct pack<std::span<byte_t> > { \
template <typename Stream> \
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::span<byte_t>& v) const { \
uint32_t size = checked_get_container_size(v.size()); \
o.pack_bin(size); \
if (size != 0) { \
o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size); \
} \
return o; \
} \
};
#define MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(byte_t) \
template <> \
struct object<std::span<byte_t> > { \
void operator()(msgpack::object& o, const std::span<byte_t>& v) const { \
uint32_t size = checked_get_container_size(v.size()); \
o.type = msgpack::type::BIN; \
if (size != 0) { \
o.via.bin.ptr = reinterpret_cast<char const*>(v.data()); \
} \
o.via.bin.size = size; \
} \
};
#define MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(byte_t) \
template <> \
struct object_with_zone<std::span<byte_t> > { \
void operator()(msgpack::object::with_zone& o, const std::span<byte_t>& v) const { \
uint32_t size = checked_get_container_size(v.size()); \
o.type = msgpack::type::BIN; \
o.via.bin.size = size; \
if (size != 0) { \
char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); \
o.via.bin.ptr = ptr; \
std::memcpy(ptr, v.data(), size); \
} \
} \
};
#define MSGPACK_ADAPTOR_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_PACK_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_PACK_SPAN_BINARY(const byte_t) \
MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(const byte_t) \
MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(const byte_t)
MSGPACK_ADAPTOR_SPAN_BINARY(char)
MSGPACK_ADAPTOR_SPAN_BINARY(unsigned char)
MSGPACK_ADAPTOR_SPAN_BINARY(std::byte)
#undef MSGPACK_ADAPTOR_SPAN_BINARY
#undef MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY
#undef MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY
#undef MSGPACK_ADAPTOR_PACK_SPAN_BINARY
#undef MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // MSGPACK_CPP_VERSION > 201703
#endif // MSGPACK_V1_TYPE_CPP11_ARRAY_HPP

3
include/msgpack/v1/adaptor/ext.hpp
View File

@ -37,7 +37,7 @@ public:
m_data.resize(static_cast<std::size_t>(s) + 1);
m_data[0] = static_cast<char>(t);
}
ext(ext_ref const&);
explicit ext(ext_ref const&);
int8_t type() const {
return static_cast<int8_t>(m_data[0]);
}
@ -167,6 +167,7 @@ public:
if (m_size < x.m_size) return false;
return std::memcmp(m_ptr, x.m_ptr, m_size) > 0;
}
private:
const char* m_ptr;
uint32_t m_size;

10
include/msgpack/v1/adaptor/map.hpp
View File

@ -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);

6
include/msgpack/v1/adaptor/raw.hpp
View File

@ -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; }
}
};

5
include/msgpack/v1/adaptor/set.hpp
View File

@ -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);

10
include/msgpack/v1/cpp_config.hpp
View File

@ -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

12
include/msgpack/v1/cpp_config_decl.hpp
View File

@ -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)

6
include/msgpack/v1/unpack.hpp
View File

@ -177,6 +177,9 @@ inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::objec
std::memcpy(tmp, p, l);
o.via.str.ptr = tmp;
}
else {
o.via.str.ptr = MSGPACK_NULLPTR;
}
o.via.str.size = l;
}
@ -193,6 +196,9 @@ inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::objec
std::memcpy(tmp, p, l);
o.via.bin.ptr = tmp;
}
else {
o.via.bin.ptr = MSGPACK_NULLPTR;
}
o.via.bin.size = l;
}

8
include/msgpack/v1/versioning.hpp
View File

@ -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

1
include/msgpack/v2/cpp_config_decl.hpp
View File

@ -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)

1
include/msgpack/v3/cpp_config_decl.hpp
View File

@ -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)

8
include/msgpack/versioning.hpp
View File

@ -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

9
msgpack-config.cmake.in Normal file
View File

@ -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)

10
test-install/CMakeLists.txt Normal file
View File

@ -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)

44
test-install/simple.cpp Normal file
View File

@ -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;
}

42
test/CMakeLists.txt
View File

@ -1,11 +1,6 @@
FIND_PACKAGE (GTest REQUIRED)
FIND_PACKAGE (ZLIB REQUIRED)
FIND_PACKAGE (Threads REQUIRED)
INCLUDE_DIRECTORIES (
${GTEST_INCLUDE_DIRS}
${ZLIB_INCLUDE_DIRS}
)
FIND_PACKAGE (ZLIB)
FIND_PACKAGE (Boost REQUIRED COMPONENTS unit_test_framework system)
LIST (APPEND check_PROGRAMS
array_ref.cpp
@ -46,7 +41,7 @@ IF (MSGPACK_USE_X3_PARSE)
)
ENDIF ()
IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
LIST (APPEND check_PROGRAMS
iterator_cpp11.cpp
msgpack_cpp11.cpp
@ -60,12 +55,18 @@ IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
)
ENDIF ()
IF (MSGPACK_CXX17)
IF (MSGPACK_CXX17 OR MSGPACK_CXX20)
LIST (APPEND check_PROGRAMS
msgpack_cpp17.cpp
)
ENDIF ()
IF (MSGPACK_CXX20)
LIST (APPEND check_PROGRAMS
msgpack_cpp20.cpp
)
ENDIF ()
FOREACH (source_file ${check_PROGRAMS})
GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
ADD_EXECUTABLE (
@ -74,12 +75,14 @@ FOREACH (source_file ${check_PROGRAMS})
)
TARGET_LINK_LIBRARIES (${source_file_we}
msgpackcxx
${GTEST_BOTH_LIBRARIES}
${ZLIB_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT}
msgpackc-cxx
Boost::system
Boost::unit_test_framework
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 ()
@ -89,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 ()
@ -100,8 +103,9 @@ ADD_EXECUTABLE (
multi_file
multi_file1.cpp multi_file2.cpp
)
TARGET_INCLUDE_DIRECTORIES (multi_file
PRIVATE
$<TARGET_PROPERTY:msgpackcxx,INTERFACE_INCLUDE_DIRECTORIES>
TARGET_LINK_LIBRARIES (multi_file
msgpackc-cxx
)
ADD_TEST (multi_file multi_file)

108
test/array_ref.cpp
View File

@ -3,22 +3,14 @@
#include <string>
#include <sstream>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_ARRAY_REF
#include <boost/test/unit_test.hpp>
#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)

42
test/boost_fusion.cpp
View File

@ -3,16 +3,8 @@
#include <iterator>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_BOOST
#include <boost/test/unit_test.hpp>
#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);
EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
BOOST_CHECK(val1.f1 == val2.f1);
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);
EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
BOOST_CHECK(val1.f1 == val2.f1);
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);
EXPECT_TRUE(val1.second == val2.second);
BOOST_CHECK(val1.first == val2.first);
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)

57
test/boost_optional.cpp
View File

@ -2,23 +2,14 @@
#include <sstream>
#include <iterator>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_BOOST
#include <boost/test/unit_test.hpp>
#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

24
test/boost_string_ref.cpp
View File

@ -2,16 +2,8 @@
#include <sstream>
#include <iterator>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_BOOST
#include <boost/test/unit_test.hpp>
#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

29
test/boost_string_view.cpp
View File

@ -2,24 +2,21 @@
#include <sstream>
#include <iterator>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_BOOST
#include <boost/test/unit_test.hpp>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// Avoid empty test tree on boost 1.60 and lower
BOOST_AUTO_TEST_CASE(dummy)
{
}
#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 +28,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

562
test/boost_variant.cpp
View File

File diff suppressed because it is too large Load Diff

46
test/buffer.cpp
View File

@ -2,40 +2,32 @@
#include <msgpack/fbuffer.hpp>
#include <msgpack/zbuffer.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE buffer
#include <boost/test/unit_test.hpp>
#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());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
BOOST_CHECK_EQUAL(3ul, sbuf.size());
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());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
BOOST_CHECK_EQUAL(3ul, sbuf.size());
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());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
BOOST_CHECK_EQUAL(3ul, sbuf.size());
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());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
BOOST_CHECK_EQUAL(3ul, sbuf.size());
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);
EXPECT_EQ('a', static_cast<char>(ch));
BOOST_CHECK(ch != EOF);
BOOST_CHECK_EQUAL('a', static_cast<char>(ch));
}
EXPECT_EQ(EOF, fgetc(file));
BOOST_CHECK_EQUAL(EOF, fgetc(file));
fclose(file);
}

72
test/buffer_c.cpp
View File

@ -3,18 +3,10 @@
#include <msgpack/sbuffer.h>
#include <msgpack/vrefbuffer.h>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE buffer
#include <boost/test/unit_test.hpp>
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#include <string.h>
#include <cstring>
#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));
EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "a", 1));
EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "a", 1));
EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "a", 1));
EXPECT_EQ(0, msgpack_zbuffer_write(&zbuf, "", 0));
BOOST_CHECK(msgpack_zbuffer_init(&zbuf, 1, MSGPACK_ZBUFFER_INIT_SIZE));
BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "a", 1));
BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "a", 1));
BOOST_CHECK_EQUAL(0, msgpack_zbuffer_write(&zbuf, "a", 1));
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 );
EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
BOOST_CHECK( file != NULL );
BOOST_CHECK_EQUAL(0, msgpack_fbuffer_write(fbuf, "a", 1));
BOOST_CHECK_EQUAL(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);
EXPECT_EQ('a', (char) ch);
BOOST_CHECK(ch != EOF);
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);
EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "a", 1));
EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "b", 1));
EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "c", 1));
EXPECT_EQ(0, msgpack_sbuffer_write(sbuf, "", 0));
EXPECT_EQ(3U, sbuf->size);
EXPECT_EQ(0, memcmp(sbuf->data, "abc", 3));
BOOST_CHECK(sbuf != NULL);
BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "a", 1));
BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "b", 1));
BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "c", 1));
BOOST_CHECK_EQUAL(0, msgpack_sbuffer_write(sbuf, "", 0));
BOOST_CHECK_EQUAL(3U, sbuf->size);
BOOST_CHECK_EQUAL(0, memcmp(sbuf->data, "abc", 3));
data = msgpack_sbuffer_release(sbuf);
EXPECT_EQ(0, memcmp(data, "abc", 3));
EXPECT_EQ(0U, sbuf->size);
EXPECT_TRUE(sbuf->data == NULL);
BOOST_CHECK_EQUAL(0, memcmp(data, "abc", 3));
BOOST_CHECK_EQUAL(0U, sbuf->size);
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);

156
test/carray.cpp
View File

@ -1,19 +1,11 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE carray
#include <boost/test/unit_test.hpp>
#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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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);
EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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);
EXPECT_EQ(o.via.str.size, static_cast<size_t>(1));
BOOST_CHECK_EQUAL(o.type, msgpack::type::STR);
BOOST_CHECK_EQUAL(o.via.str.size, static_cast<size_t>(1));
char v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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);
EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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);
EXPECT_EQ(o.via.bin.size, static_cast<size_t>(2));
BOOST_CHECK_EQUAL(o.type, msgpack::type::BIN);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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]);
EXPECT_EQ(v1[1], v2[1]);
BOOST_CHECK_EQUAL(v1[0], v2[0]);
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

20
test/cases.cpp
View File

@ -1,16 +1,8 @@
#include <msgpack.hpp>
#include <fstream>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE cases
#include <boost/test/unit_test.hpp>
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) );
EXPECT_EQ(oh_compact.get(), oh.get());
BOOST_CHECK( pac_compact.next(oh_compact) );
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__)

56
test/convert.cpp
View File

@ -1,15 +1,7 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE convert
#include <boost/test/unit_test.hpp>
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);
EXPECT_EQ("default", c.str2);
BOOST_CHECK_EQUAL("kumofs", c.str1);
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);
EXPECT_EQ("mpio", to.str2);
BOOST_CHECK_EQUAL("kumofs", to.str1);
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);
EXPECT_EQ(i, j);
BOOST_CHECK_EQUAL(&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));
EXPECT_EQ(i, 1);
BOOST_CHECK(obj.convert_if_not_nil(i));
BOOST_CHECK_EQUAL(i, 1);
}

22
test/fixint.cpp
View File

@ -1,25 +1,17 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE fixint
#include <boost/test/unit_test.hpp>
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>();

16
test/fuzz_unpack_pack_fuzzer_cpp11.cpp
View File

@ -1,17 +1,9 @@
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE FUZZ_UNPACK_PACK_FUZZER
#include <boost/test/unit_test.hpp>
#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));
}

40
test/iterator_cpp11.cpp
View File

@ -1,22 +1,12 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE iterator
#include <boost/test/unit_test.hpp>
#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++) {
map[static_cast<unsigned int>(rand())] = static_cast<unsigned int>(rand());
for (unsigned i = 0; i < MAP_SIZE; i++) {
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 val = kv.val.as<unsigned int>();
auto key = kv.key.as<unsigned>();
auto val = kv.val.as<unsigned>();
auto correct = map[key];
EXPECT_EQ(val, correct);
BOOST_CHECK_EQUAL(val, correct);
}
}

24
test/json.cpp
View File

@ -2,18 +2,10 @@
#include <fstream>
#include <sstream>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE json
#include <boost/test/unit_test.hpp>
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
TEST(json, basic_elements)
BOOST_AUTO_TEST_CASE(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 \"");
}

214
test/limit.cpp
View File

@ -1,19 +1,11 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE limit
#include <boost/test/unit_test.hpp>
#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());
}

350
test/msgpack_basic.cpp
View File

@ -9,16 +9,9 @@
#include <list>
#include <limits>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK
#include <boost/test/unit_test.hpp>
#include <boost/mpl/list.hpp>
#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>
class IntegerToFloatingPointTest : public testing::Test {
};
TYPED_TEST_CASE_P(IntegerToFloatingPointTest);
typedef boost::mpl::list<TypePair<float, signed long long>,
TypePair<float, unsigned long long>,
TypePair<double, signed long long>,
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_EQ(2, oh.get().via.ext.data()[0]);
BOOST_CHECK_EQUAL(1ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_EQ(2, oh2.get().via.ext.data()[0]);
BOOST_CHECK_EQUAL(1ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
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);
EXPECT_EQ(0, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(2ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(0, oh.get().via.ext.type());
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);
EXPECT_EQ(0, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(2ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(0, oh2.get().via.ext.type());
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(4ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(4ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(8ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(8ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(16ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(16ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
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());
EXPECT_EQ(77, e.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, e.size());
BOOST_CHECK_EQUAL(77, e.type());
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());
EXPECT_EQ(77, val2.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, val2.size());
BOOST_CHECK_EQUAL(77, val2.type());
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());
EXPECT_EQ(77, er.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, er.size());
BOOST_CHECK_EQUAL(77, er.type());
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());
EXPECT_EQ(77, val2.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(data_size, val2.size());
BOOST_CHECK_EQUAL(77, val2.type());
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());
EXPECT_EQ(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);
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1, val2);
}
}

396
test/msgpack_container.cpp
View File

@ -12,16 +12,8 @@
#include "test_allocator.hpp"
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_STL
#include <boost/test/unit_test.hpp>
#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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
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);
EXPECT_EQ(val1.second, val2.second);
BOOST_CHECK_EQUAL(val1.first, val2.first);
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());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.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());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.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);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
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);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
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);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
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);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
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);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
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());
EXPECT_EQ(it->second, val2.find(it->first)->second);
BOOST_CHECK(val2.find(it->first) != val2.end());
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());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.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());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.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());
EXPECT_EQ(it->second, val2.find(it->first)->second);
BOOST_CHECK(val2.find(it->first) != val2.end());
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());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.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());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.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

549
test/msgpack_cpp11.cpp
View File

File diff suppressed because it is too large Load Diff

239
test/msgpack_cpp17.cpp
View File

@ -1,32 +1,24 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_CPP17
#include <boost/test/unit_test.hpp>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// To avoid link error
TEST(MSGPACK_CPP17, dummy)
// For C++ standards lower than C++17
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{
@ -271,21 +263,21 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
std::string const& str = ss.str();
EXPECT_EQ(str[i], packed[i]);
BOOST_CHECK_EQUAL(str[i], packed[i]);
}
msgpack::object_handle oh;
std::string const& str = ss.str();
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,129 @@ 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, carray_byte_pack_convert)
BOOST_AUTO_TEST_CASE(array_byte_pack_convert)
{
std::stringstream ss;
std::array<std::byte, 5> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(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>>();
BOOST_CHECK(val1 == val2);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 0>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
}
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}
};
// Caller need to manage val1's lifetime. The Data is not copied.
msgpack::object obj(val1);
auto val2 = obj.as<std::array<std::byte, 5>>();
BOOST_CHECK(val1 == val2);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
BOOST_AUTO_TEST_CASE(array_byte_object_with_zone)
{
msgpack::zone z;
std::array<std::byte, 5> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::object obj(val1, z);
auto val2 = obj.as<std::array<std::byte, 5>>();
BOOST_CHECK(val1 == val2);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
BOOST_AUTO_TEST_CASE(array_byte_empty_pack_convert)
{
std::stringstream ss;
std::array<std::byte, 0> val1{};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x00) };
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(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>>();
BOOST_CHECK(val1 == val2);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
}
BOOST_AUTO_TEST_CASE(array_byte_empty_object)
{
std::array<std::byte, 0> val1{};
// Caller need to manage val1's lifetime. The Data is not copied.
msgpack::object obj(val1);
auto val2 = obj.as<std::array<std::byte, 0>>();
BOOST_CHECK(val1 == val2);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
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>>();
BOOST_CHECK(val1 == val2);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
BOOST_AUTO_TEST_CASE(carray_byte_pack_convert)
{
std::stringstream ss;
std::byte val1[] = {
@ -318,24 +429,24 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
std::string const& str = ss.str();
EXPECT_EQ(str[i], packed[i]);
BOOST_CHECK_EQUAL(str[i], packed[i]);
}
msgpack::object_handle oh;
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
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[] = {
@ -346,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

131
test/msgpack_cpp20.cpp Normal file
View File

@ -0,0 +1,131 @@
#include <msgpack.hpp>
#define BOOST_TEST_MODULE MSGPACK_CPP20
#include <boost/test/unit_test.hpp>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// For C++ standards lower than C++20
BOOST_AUTO_TEST_CASE(dummy)
{
}
// Some compilers still do not set the corresponding macro to 202002
#if MSGPACK_CPP_VERSION > 201703
#if MSGPACK_HAS_INCLUDE(<span>)
template <typename Byte>
bool operator==(const std::span<const Byte>& lhs, const std::span<const Byte>& rhs)
{
if (lhs.size() != rhs.size())
return false;
for (std::size_t i = 0; i < lhs.size(); ++i)
if (lhs[i] != rhs[i])
return false;
return true;
}
template <typename Byte>
bool operator==(const std::span<const Byte>& lhs, const std::vector<Byte>& rhs)
{
return lhs == std::span<const Byte>{rhs.data(), rhs.size()};
}
template <typename Byte>
bool operator==(const std::vector<Byte>& lhs, const std::span<const Byte>& rhs)
{
return std::span<const Byte>{lhs.data(), lhs.size()} == rhs;
}
#define MSGPACK_TEST_SPAN_BYTE_PACK_CONVERT(byte_t, display_name) \
BOOST_AUTO_TEST_CASE(span_##display_name##_pack_convert) \
{ \
std::stringstream ss; \
byte_t raw_data[] = { \
(byte_t)(0x01), (byte_t)(0x02), (byte_t)(0x7f), (byte_t)(0x80), (byte_t)(0xff) \
}; \
std::span<const byte_t> val1{raw_data, sizeof(raw_data)}; \
\
msgpack::pack(ss, val1); \
std::string const& str = ss.str(); \
\
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) }; \
BOOST_CHECK_EQUAL(str.size(), sizeof(packed)); \
for (size_t i = 0; i != sizeof(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>>(); \
BOOST_CHECK(val1 == val2); \
} \
{ \
auto val2 = oh.get().as<std::span<const byte_t>>(); \
BOOST_CHECK(val1 == val2); \
} \
} \
#define MSGPACK_TEST_SPAN_BYTE_OBJECT(byte_t, display_name) \
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) \
}; \
std::span<const byte_t> val1{raw_data, sizeof(raw_data)}; \
\
/* Caller needs to manage val1's lifetime. The Data is not copied. */ \
msgpack::object obj(val1); \
\
{ \
auto val2 = obj.as<std::vector<byte_t>>(); \
BOOST_CHECK(val1 == val2); \
} \
{ \
auto val2 = obj.as<std::span<const byte_t>>(); \
BOOST_CHECK(val1 == val2); \
} \
} \
#define MSGPACK_TEST_SPAN_BYTE_OBJECT_WITH_ZONE(byte_t, display_name) \
BOOST_AUTO_TEST_CASE(span_##display_name##_object_with_zone) \
{ \
msgpack::zone z; \
byte_t raw_data[] = { \
(byte_t)(0x01), (byte_t)(0x02), (byte_t)(0x7f), (byte_t)(0x80), (byte_t)(0xff) \
}; \
std::span<const byte_t> val1(raw_data, sizeof(raw_data)); \
\
msgpack::object obj(val1, z); \
\
{ \
auto val2 = obj.as<std::vector<byte_t>>(); \
BOOST_CHECK(val1 == val2); \
} \
{ \
auto val2 = obj.as<std::span<const byte_t>>(); \
BOOST_CHECK(val1 == val2); \
} \
} \
#define MSGPACK_TEST_SPAN_BYTE(byte_t, display_name) \
MSGPACK_TEST_SPAN_BYTE_PACK_CONVERT(byte_t, display_name) \
MSGPACK_TEST_SPAN_BYTE_OBJECT(byte_t, display_name) \
MSGPACK_TEST_SPAN_BYTE_OBJECT_WITH_ZONE(byte_t, display_name) \
MSGPACK_TEST_SPAN_BYTE(std::byte, byte)
MSGPACK_TEST_SPAN_BYTE(char, char)
MSGPACK_TEST_SPAN_BYTE(unsigned char, unsigned_char)
#undef MSGPACK_TEST_SPAN_BYTE
#undef MSGPACK_TEST_SPAN_BYTE_OBJECT_WITH_ZONE
#undef MSGPACK_TEST_SPAN_BYTE_OBJECT
#undef MSGPACK_TEST_SPAN_BYTE_PACK_CONVERT
#endif // MSGPACK_HAS_INCLUDE(<span>)
#endif // MSGPACK_CPP_VERSION > 201703

52
test/msgpack_stream.cpp
View File

@ -9,16 +9,8 @@
#include <list>
#include <limits>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK
#include <boost/test/unit_test.hpp>
#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);
}

112
test/msgpack_tuple.cpp
View File

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

96
test/msgpack_vref.cpp
View File

@ -9,16 +9,8 @@
#include <list>
#include <limits>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK
#include <boost/test/unit_test.hpp>
#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);
}

318
test/msgpack_x3_parse.cpp
View File

@ -4,19 +4,11 @@
#include <limits>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_X3_PARSE
#include <boost/test/unit_test.hpp>
// 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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_EQ(2, oh.get().via.ext.data()[0]);
BOOST_CHECK_EQUAL(1ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(0, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(2ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(0, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(4ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(8ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(16ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
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);
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK(!r);
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);
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK(r);
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);
EXPECT_EQ(v, obj.as<std::string>());
BOOST_CHECK(!r);
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);
EXPECT_EQ(v, obj.as<std::string>());
BOOST_CHECK(r);
BOOST_CHECK_EQUAL(v, obj.as<std::string>());
}
#endif // defined(MSGPACK_USE_X3_PARSE) && MSGPACK_DEFAULT_API_VERSION >= 2

367
test/object.cpp
View File

@ -1,15 +1,7 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE object
#include <boost/test/unit_test.hpp>
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');
EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
EXPECT_NE(
BOOST_CHECK_EQUAL(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].val.via.bin.ptr[0], 't');
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(
obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr,
BOOST_CHECK(
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(
obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr,
BOOST_CHECK(
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');
EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
EXPECT_NE(
BOOST_CHECK_EQUAL(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].val.via.bin.ptr[0], 't');
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(
obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr,
BOOST_CHECK(
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(
obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr,
BOOST_CHECK(
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);
EXPECT_EQ(obj2.via.ext.ptr[0], 1);
EXPECT_EQ(obj2.via.ext.ptr[1], 2);
EXPECT_NE(
obj1.via.ext.ptr,
BOOST_CHECK_EQUAL(obj2.via.ext.size, 1u);
BOOST_CHECK_EQUAL(obj2.via.ext.ptr[0], 1);
BOOST_CHECK_EQUAL(obj2.via.ext.ptr[1], 2);
BOOST_CHECK(
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);
EXPECT_EQ(obj2.via.ext.ptr[0], 1);
EXPECT_EQ(obj2.via.ext.ptr[1], 2);
EXPECT_NE(
obj1.via.ext.ptr,
BOOST_CHECK_EQUAL(obj2.via.ext.size, 1u);
BOOST_CHECK_EQUAL(obj2.via.ext.ptr[0], 1);
BOOST_CHECK_EQUAL(obj2.via.ext.ptr[1], 2);
BOOST_CHECK(
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");
}
TEST(object, is_nil)
BOOST_AUTO_TEST_CASE(is_nil)
{
msgpack::object obj;
EXPECT_TRUE(obj.is_nil());
BOOST_CHECK(obj.is_nil());
}
TEST(object, type_error)
BOOST_AUTO_TEST_CASE(type_error)
{
msgpack::object obj(1);
EXPECT_THROW(obj.as<std::string>(), msgpack::type_error);
EXPECT_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
EXPECT_EQ(1, obj.as<int>());
EXPECT_EQ(1, obj.as<short>());
EXPECT_EQ(1u, obj.as<unsigned int>());
EXPECT_EQ(1u, obj.as<unsigned long>());
BOOST_CHECK_THROW(obj.as<std::string>(), msgpack::type_error);
BOOST_CHECK_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
BOOST_CHECK_EQUAL(1, obj.as<int>());
BOOST_CHECK_EQUAL(1, obj.as<short>());
BOOST_CHECK_EQUAL(1u, obj.as<unsigned int>());
BOOST_CHECK_EQUAL(1u, obj.as<unsigned long>());
}
TEST(object, equal_primitive)
BOOST_AUTO_TEST_CASE(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));
EXPECT_EQ(obj_int, 1);
BOOST_CHECK_EQUAL(obj_int, msgpack::object(1));
BOOST_CHECK_EQUAL(obj_int, 1);
msgpack::object obj_float(1.2);
EXPECT_EQ(obj_float, msgpack::object(1.2));
EXPECT_EQ(obj_float, 1.2);
BOOST_CHECK_EQUAL(obj_float, msgpack::object(1.2));
BOOST_CHECK_EQUAL(obj_float, 1.2);
msgpack::object obj_bool(true);
EXPECT_EQ(obj_bool, msgpack::object(true));
EXPECT_EQ(obj_bool, true);
BOOST_CHECK_EQUAL(obj_bool, msgpack::object(true));
BOOST_CHECK_EQUAL(obj_bool, true);
}
TEST(object, construct_primitive)
BOOST_AUTO_TEST_CASE(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);
EXPECT_EQ(1u, obj_uint.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj_uint.type);
BOOST_CHECK_EQUAL(1u, obj_uint.via.u64);
msgpack::object obj_int(-1);
EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
EXPECT_EQ(-1, obj_int.via.i64);
BOOST_CHECK_EQUAL(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
BOOST_CHECK_EQUAL(-1, obj_int.via.i64);
msgpack::object obj_float(1.2F);
EXPECT_EQ(msgpack::type::FLOAT32, obj_float.type);
EXPECT_EQ(1.2F, obj_float.via.f64);
BOOST_CHECK_EQUAL(msgpack::type::FLOAT32, obj_float.type);
BOOST_CHECK_EQUAL(1.2F, obj_float.via.f64);
msgpack::object obj_double(1.2);
EXPECT_EQ(msgpack::type::FLOAT64, obj_double.type);
EXPECT_EQ(msgpack::type::FLOAT, obj_double.type);
EXPECT_EQ(1.2, obj_double.via.f64);
BOOST_CHECK_EQUAL(msgpack::type::FLOAT64, obj_double.type);
BOOST_CHECK_EQUAL(msgpack::type::FLOAT, obj_double.type);
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);
EXPECT_EQ(1.2, obj_double.via.dec);
BOOST_CHECK_EQUAL(msgpack::type::DOUBLE, obj_double.type);
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);
EXPECT_EQ(true, obj_bool.via.boolean);
BOOST_CHECK_EQUAL(msgpack::type::BOOLEAN, obj_bool.type);
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);
EXPECT_EQ(static_cast<uint64_t>(elem), obj.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
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);
EXPECT_EQ(elem, obj.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
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);
EXPECT_EQ(static_cast<uint64_t>(elem), obj.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
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);
EXPECT_EQ(elem, obj.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
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);
EXPECT_EQ(elem, obj.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
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);
EXPECT_EQ(elem, obj.via.u64);
BOOST_CHECK_EQUAL(msgpack::type::POSITIVE_INTEGER, obj.type);
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);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
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);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
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);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
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());
EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
BOOST_CHECK_EQUAL(v.size(), v2.size());
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);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
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());
EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
BOOST_CHECK_EQUAL(v.size(), v2.size());
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);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
BOOST_CHECK_EQUAL(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
BOOST_CHECK_EQUAL(h.get(), obj);
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());
EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
BOOST_CHECK_EQUAL(v.size(), v2.size());
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());
EXPECT_EQ(ss1.str(), ss2.str());
BOOST_CHECK_EQUAL(static_cast<size_t>(5), ss1.str().size());
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());
EXPECT_EQ(ss1.str(), ss2.str());
BOOST_CHECK_EQUAL(static_cast<size_t>(9), ss1.str().size());
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);
EXPECT_EQ(oh->as<int>(), oh.get().as<int>());
BOOST_CHECK_EQUAL(oh.get(), *oh);
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

619
test/object_with_zone.cpp
View File

File diff suppressed because it is too large Load Diff

254
test/pack_unpack.cpp
View File

@ -1,26 +1,18 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE pack_unpack
#include <boost/test/unit_test.hpp>
#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>());
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_FALSE(referenced);
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_FALSE(referenced);
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
BOOST_CHECK(!referenced);
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>());
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_FALSE(referenced);
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_FALSE(referenced);
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
BOOST_CHECK(!referenced);
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>());
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_FALSE(referenced);
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
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>());
EXPECT_EQ(off, sbuf.size());
EXPECT_FALSE(referenced);
BOOST_CHECK_EQUAL(1, oh.get().as<int>());
BOOST_CHECK_EQUAL(off, sbuf.size());
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>());
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, obj.as<int>());
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>());
EXPECT_FALSE(referenced);
BOOST_CHECK_EQUAL(1, obj.as<int>());
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>());
EXPECT_FALSE(referenced);
EXPECT_EQ(off, sbuf.size());
BOOST_CHECK_EQUAL(1, obj.as<int>());
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(off, 2u);
BOOST_CHECK(thrown);
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);
EXPECT_EQ(oh.get().via.array.size, 0u);
EXPECT_EQ(off, 1u);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
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);
EXPECT_EQ(oh.get().via.array.size, 0u);
EXPECT_EQ(off, 3u);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
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);
EXPECT_EQ(oh.get().via.array.size, 0u);
EXPECT_EQ(off, 5u);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
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);
EXPECT_EQ(oh.get().via.map.size, 0u);
EXPECT_EQ(off, 1u);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::MAP);
BOOST_CHECK_EQUAL(oh.get().via.map.size, 0u);
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);
EXPECT_EQ(oh.get().via.map.size, 0u);
EXPECT_EQ(off, 3u);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::MAP);
BOOST_CHECK_EQUAL(oh.get().via.map.size, 0u);
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);
EXPECT_EQ(oh.get().via.map.size, 0u);
EXPECT_EQ(off, 5u);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::MAP);
BOOST_CHECK_EQUAL(oh.get().via.map.size, 0u);
BOOST_CHECK_EQUAL(off, 5u);
}

150
test/raw.cpp
View File

@ -3,22 +3,14 @@
#include <string>
#include <sstream>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_RAW_REF
#include <boost/test/unit_test.hpp>
#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));
EXPECT_EQ(packed_str[1], static_cast<char>(0x03u));
EXPECT_EQ(packed_str[2], 'A');
EXPECT_EQ(packed_str[3], 'B');
EXPECT_EQ(packed_str[4], 'C');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc4u));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x03u));
BOOST_CHECK_EQUAL(packed_str[2], 'A');
BOOST_CHECK_EQUAL(packed_str[3], 'B');
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc4u));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc4u));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0xffu));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0x01));
EXPECT_EQ(packed_str[2], static_cast<char>(0x00));
EXPECT_EQ(packed_str[3], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc5u));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x01));
BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x00));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[3], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc5u));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0xffu));
BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0xffu));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00));
EXPECT_EQ(packed_str[2], static_cast<char>(0x01));
EXPECT_EQ(packed_str[3], static_cast<char>(0x00));
EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
EXPECT_EQ(packed_str[5], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xc6u));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00));
BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x01));
BOOST_CHECK_EQUAL(packed_str[3], static_cast<char>(0x00));
BOOST_CHECK_EQUAL(packed_str[4], static_cast<char>(0x00));
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));
EXPECT_EQ(packed_str[1], 'A');
EXPECT_EQ(packed_str[2], 'B');
EXPECT_EQ(packed_str[3], 'C');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xa3u));
BOOST_CHECK_EQUAL(packed_str[1], 'A');
BOOST_CHECK_EQUAL(packed_str[2], 'B');
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));
EXPECT_EQ(packed_str[1], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xbfu));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
EXPECT_EQ(packed_str[2], static_cast<char>(0x20u));
EXPECT_EQ(packed_str[3], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xdau));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00u));
BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x20u));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[3], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xdau));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0xffu));
BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0xffu));
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));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00));
EXPECT_EQ(packed_str[2], static_cast<char>(0x01));
EXPECT_EQ(packed_str[3], static_cast<char>(0x00));
EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
EXPECT_EQ(packed_str[5], 'A');
BOOST_CHECK_EQUAL(packed_str[0], static_cast<char>(0xdbu));
BOOST_CHECK_EQUAL(packed_str[1], static_cast<char>(0x00));
BOOST_CHECK_EQUAL(packed_str[2], static_cast<char>(0x01));
BOOST_CHECK_EQUAL(packed_str[3], static_cast<char>(0x00));
BOOST_CHECK_EQUAL(packed_str[4], static_cast<char>(0x00));
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);
}

170
test/reference.cpp
View File

@ -1,17 +1,9 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE reference
#include <boost/test/unit_test.hpp>
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
TEST(reference, unpack_int)
BOOST_AUTO_TEST_CASE(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);
EXPECT_EQ(MSGPACK_NULLPTR, s_p);
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(referenced);
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);
EXPECT_FALSE(referenced);
BOOST_CHECK(b);
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);
EXPECT_TRUE(referenced);
BOOST_CHECK(b);
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);
EXPECT_TRUE(referenced);
BOOST_CHECK(b);
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);
EXPECT_TRUE(referenced);
BOOST_CHECK(b);
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);
EXPECT_FALSE(referenced);
EXPECT_EQ(MSGPACK_NULLPTR, s_p);
BOOST_CHECK(b);
BOOST_CHECK(!referenced);
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);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(b);
BOOST_CHECK(!referenced);
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);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(b);
BOOST_CHECK(referenced);
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);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(b);
BOOST_CHECK(!referenced);
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);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(b);
BOOST_CHECK(referenced);
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);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(b);
BOOST_CHECK(!referenced);
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);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(b);
BOOST_CHECK(referenced);
BOOST_CHECK_EQUAL(&sbuf, s_p);
}

90
test/reference_cpp11.cpp
View File

@ -1,39 +1,31 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE reference
#include <boost/test/unit_test.hpp>
#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);
EXPECT_EQ(MSGPACK_NULLPTR, s_p);
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(!referenced);
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);
EXPECT_EQ(&sbuf, s_p);
BOOST_CHECK(referenced);
BOOST_CHECK_EQUAL(&sbuf, s_p);
}
#endif // !defined(MSGPACK_USE_CPP03)

42
test/reference_wrapper_cpp11.cpp
View File

@ -1,16 +1,8 @@
#include <msgpack.hpp>
#include <sstream>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_REFERENCE_WRAPPER
#include <boost/test/unit_test.hpp>
#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));
EXPECT_EQ(val1[0], val2[0]);
BOOST_CHECK_EQUAL(val2.size(), static_cast<size_t>(1));
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)

45
test/shared_ptr_cpp11.cpp
View File

@ -2,24 +2,15 @@
#include <sstream>
#include <iterator>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE SHARED_PTR
#include <boost/test/unit_test.hpp>
#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);
}

108
test/size_equal_only.cpp
View File

@ -1,18 +1,10 @@
#include <sstream>
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE size_equal_only
#include <boost/test/unit_test.hpp>
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
TEST(size_equal_only, array)
BOOST_AUTO_TEST_CASE(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]);
EXPECT_EQ(buf[1], ret_buf1[1]);
EXPECT_EQ(buf[2], ret_buf1[2]);
BOOST_CHECK_EQUAL(buf[0], ret_buf1[0]);
BOOST_CHECK_EQUAL(buf[1], ret_buf1[1]);
BOOST_CHECK_EQUAL(buf[2], ret_buf1[2]);
int ret_buf2[4];
oh.get().convert(ret_buf2);
EXPECT_EQ(buf[0], ret_buf2[0]);
EXPECT_EQ(buf[1], ret_buf2[1]);
EXPECT_EQ(buf[2], ret_buf2[2]);
BOOST_CHECK_EQUAL(buf[0], ret_buf2[0]);
BOOST_CHECK_EQUAL(buf[1], ret_buf2[1]);
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]);
EXPECT_EQ(buf[1], ret_buf3[1]);
EXPECT_EQ(buf[2], ret_buf3[2]);
BOOST_CHECK_EQUAL(buf[0], ret_buf3[0]);
BOOST_CHECK_EQUAL(buf[1], ret_buf3[1]);
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>());
EXPECT_EQ(buf.get<1>(), ret_buf1.get<1>());
EXPECT_EQ(buf.get<2>(), ret_buf1.get<2>());
BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf1.get<0>());
BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf1.get<1>());
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>());
EXPECT_EQ(buf.get<1>(), ret_buf2.get<1>());
EXPECT_EQ(buf.get<2>(), ret_buf2.get<2>());
BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf2.get<0>());
BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf2.get<1>());
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>());
EXPECT_EQ(buf.get<1>(), ret_buf3.get<1>());
EXPECT_EQ(buf.get<2>(), ret_buf3.get<2>());
BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf3.get<0>());
BOOST_CHECK_EQUAL(buf.get<1>(), ret_buf3.get<1>());
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>());
EXPECT_EQ(buf.get<1>(), ret_buf5.get<1>());
BOOST_CHECK_EQUAL(buf.get<0>(), ret_buf5.get<0>());
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));
EXPECT_EQ(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<0>(buf), std::get<0>(ret_buf3));
BOOST_CHECK_EQUAL(std::get<1>(buf), std::get<1>(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));
EXPECT_EQ(std::get<1>(buf), std::get<1>(ret_buf5));
BOOST_CHECK_EQUAL(std::get<0>(buf), std::get<0>(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);
}
}

58
test/streaming.cpp
View File

@ -1,19 +1,11 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE streaming
#include <boost/test/unit_test.hpp>
#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);

32
test/test_allocator.hpp
View File

@ -11,6 +11,8 @@
#ifndef TEST_ALLOCATOR_HPP
#define TEST_ALLOCATOR_HPP
#include <msgpack/cpp_version.hpp>
#include <memory>
namespace test {
@ -18,13 +20,20 @@ namespace test {
template <typename T>
struct allocator {
typedef typename std::allocator<T>::value_type value_type;
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 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;
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; };
#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 // MSGPACK_CPP_VERSION <= 201703
#if defined(MSGPACK_USE_CPP03)
allocator() throw() {}
allocator (const allocator& alloc) throw()
@ -45,11 +54,21 @@ struct allocator {
template <class U>
allocator (const allocator<U>& alloc) noexcept
:alloc_(alloc.alloc_) {}
#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 // 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)...);
}
size_type max_size() const noexcept {
return std::allocator_traits<decltype(alloc_)>::max_size(alloc_);
}
#endif // MSGPACK_CPP_VERSION <= 201703
#endif // defined(MSGPACK_USE_CPP03)
pointer allocate (size_type n) {
return alloc_.allocate(n);
@ -57,9 +76,16 @@ struct allocator {
void deallocate (pointer p, size_type n) {
return alloc_.deallocate(p, n);
}
#if MSGPACK_CPP_VERSION <= 201703
void destroy (pointer p) {
alloc_.destroy(p);
}
#else // MSGPACK_CPP_VERSION <= 201703
void destroy (pointer p) {
std::allocator_traits<decltype(alloc_)>::destroy(alloc_, p);
}
#endif // MSGPACK_CPP_VERSION <= 201703
std::allocator<T> alloc_;
};

44
test/unique_ptr_cpp11.cpp
View File

@ -2,16 +2,8 @@
#include <sstream>
#include <iterator>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE UNIQUE_PTR
#include <boost/test/unit_test.hpp>
#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);
}

180
test/user_class.cpp
View File

@ -2,23 +2,13 @@
#include <string>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_USER_DEFINED
#include <boost/test/unit_test.hpp>
#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);
EXPECT_EQ(val1.s, val2.s);
BOOST_CHECK_EQUAL(val1.i, val2.i);
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);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());
BOOST_CHECK_EQUAL(val1.i, val2.i);
BOOST_CHECK_EQUAL(val1.s, val2.s);
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);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());
BOOST_CHECK_EQUAL(val1.i, val2.i);
BOOST_CHECK_EQUAL(val1.s, val2.s);
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);
EXPECT_EQ(val1.t2, val2.t2);
EXPECT_EQ(val1.t3, val2.t3);
BOOST_CHECK_EQUAL(val1.t1, val2.t1);
BOOST_CHECK_EQUAL(val1.t2, val2.t2);
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);
EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
BOOST_CHECK_EQUAL(val1.is_double, val2.is_double);
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);
EXPECT_EQ(val1.value.i, 1);
EXPECT_EQ(val1.value.i, val2.value.i);
BOOST_CHECK_EQUAL(val1.is_double, val2.is_double);
BOOST_CHECK_EQUAL(val1.value.i, 1);
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);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.d_mid1::t, br.d_mid1::t);
EXPECT_EQ(b.d_mid2::t, br.d_mid2::t);
BOOST_CHECK_EQUAL(b.b, br.b);
BOOST_CHECK_EQUAL(b.m1, br.m1);
BOOST_CHECK_EQUAL(b.m2, br.m2);
BOOST_CHECK_EQUAL(b.d_mid1::t, br.d_mid1::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);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.t, br.t);
BOOST_CHECK_EQUAL(b.b, br.b);
BOOST_CHECK_EQUAL(b.m1, br.m1);
BOOST_CHECK_EQUAL(b.m2, br.m2);
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);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.da_mid1::t, br.da_mid1::t);
EXPECT_EQ(b.da_mid2::t, br.da_mid2::t);
BOOST_CHECK_EQUAL(b.b, br.b);
BOOST_CHECK_EQUAL(b.m1, br.m1);
BOOST_CHECK_EQUAL(b.m2, br.m2);
BOOST_CHECK_EQUAL(b.da_mid1::t, br.da_mid1::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);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.t, br.t);
BOOST_CHECK_EQUAL(b.b, br.b);
BOOST_CHECK_EQUAL(b.m1, br.m1);
BOOST_CHECK_EQUAL(b.m2, br.m2);
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);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.dm_mid1::t, br.dm_mid1::t);
EXPECT_EQ(b.dm_mid2::t, br.dm_mid2::t);
BOOST_CHECK_EQUAL(b.b, br.b);
BOOST_CHECK_EQUAL(b.m1, br.m1);
BOOST_CHECK_EQUAL(b.m2, br.m2);
BOOST_CHECK_EQUAL(b.dm_mid1::t, br.dm_mid1::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);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.t, br.t);
BOOST_CHECK_EQUAL(b.b, br.b);
BOOST_CHECK_EQUAL(b.m1, br.m1);
BOOST_CHECK_EQUAL(b.m2, br.m2);
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');
EXPECT_EQ(v2.s, "foo"); // from v1
EXPECT_EQ(v2.i, 42); // from v1
BOOST_CHECK_EQUAL(v2.c, 'A');
BOOST_CHECK_EQUAL(v2.s, "foo"); // 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");
EXPECT_EQ(obj.via.map.ptr[0].val.via.i64, 3);
BOOST_CHECK_EQUAL(std::string(obj.via.map.ptr[0].key.via.str.ptr, obj.via.map.ptr[0].key.via.str.size), "ccc");
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");
EXPECT_EQ(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].key.via.str.ptr, obj.via.map.ptr[1].key.via.str.size), "base");
BOOST_CHECK_EQUAL(obj.via.map.ptr[1].val.via.map.size, static_cast<size_t>(2));
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);
EXPECT_EQ(
BOOST_CHECK_EQUAL(obj.via.map.ptr[1].val.via.map.ptr[0].val.via.i64, 1);
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");
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].key.via.str.ptr, obj.via.map.ptr[2].key.via.str.size), "ddd");
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);
EXPECT_EQ(d2.b, 2);
EXPECT_EQ(d2.c, 3);
EXPECT_EQ(d2.d, "ABC");
BOOST_CHECK_EQUAL(d2.a, 1);
BOOST_CHECK_EQUAL(d2.b, 2);
BOOST_CHECK_EQUAL(d2.c, 3);
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);
}
}

30
test/version.cpp
View File

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

183
test/visitor.cpp
View File

@ -1,20 +1,11 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE visitor
#include <boost/test/unit_test.hpp>
#include <sstream>
// To avoid link error
TEST(visitor, dummy)
BOOST_AUTO_TEST_CASE(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);
EXPECT_EQ("{\"key\":[42,null,true]}", json_like);
BOOST_CHECK(ret);
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);
EXPECT_EQ(static_cast<size_t>(2), error_offset);
BOOST_CHECK_EQUAL(static_cast<size_t>(1), parsed_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);
EXPECT_TRUE(called);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(static_cast<size_t>(3), error_offset);
BOOST_CHECK_EQUAL(static_cast<size_t>(2), parsed_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);
EXPECT_TRUE(called);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(0u, off);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(0u, off);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(0u, off);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(2u, times);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(0u, off);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(0u, off);
BOOST_CHECK(!ret);
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);
EXPECT_EQ(0u, off);
BOOST_CHECK(!ret);
BOOST_CHECK_EQUAL(0u, off);
}
#endif // MSGPACK_DEFAULT_API_VERSION >= 1

48
test/zone.cpp
View File

@ -1,38 +1,30 @@
#include <msgpack.hpp>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE zone
#include <boost/test/unit_test.hpp>
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
TEST(zone, allocate_align)
BOOST_AUTO_TEST_CASE(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);
EXPECT_EQ(m->str, "default");
BOOST_CHECK_EQUAL(m->num, 0);
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);
EXPECT_EQ(m->str, "msgpack");
BOOST_CHECK_EQUAL(m->num, 7);
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* buf2 = (char*)z.allocate_no_align(4);
EXPECT_EQ(buf1+4, buf2);
char* buf1 = reinterpret_cast<char*>(z.allocate_no_align(4));
char* buf2 = reinterpret_cast<char*>(z.allocate_no_align(4));
BOOST_CHECK_EQUAL(reinterpret_cast<void*>(buf1+4), reinterpret_cast<void*>(buf2));
}